Error Handling

{
  "detail": "Deal not found",
  "code": "DEAL_NOT_FOUND",
  "errors": []
}

import time
import requests
from requests.exceptions import HTTPError

BANKLYZE_API_KEY = "bk_your_api_key"
BASE_URL = "https://api.banklyze.com/v1"


def api_request_with_retry(method: str, path: str, **kwargs) -> dict:
    """Make a Banklyze API request with exponential backoff retry."""
    url = f"{BASE_URL}{path}"
    headers = {"X-API-Key": BANKLYZE_API_KEY, **kwargs.pop("headers", {})}

    max_retries = 4
    backoff = 1  # seconds

    for attempt in range(max_retries):
        response = requests.request(method, url, headers=headers, **kwargs)

        if response.status_code == 429:
            # Respect Retry-After if present, otherwise use exponential backoff
            retry_after = response.headers.get("Retry-After")
            wait = int(retry_after) if retry_after else backoff * (2 ** attempt)
            print(f"Rate limited. Retrying in {wait}s (attempt {attempt + 1})")
            time.sleep(wait)
            continue

        if response.status_code >= 500:
            if attempt < max_retries - 1:
                wait = backoff * (2 ** attempt)
                print(f"Server error {response.status_code}. Retrying in {wait}s")
                time.sleep(wait)
                continue

        response.raise_for_status()
        return response.json()

    raise RuntimeError("Max retries exceeded")


# Usage
deals = api_request_with_retry("GET", "/deals")

#!/usr/bin/env bash
# Retry a curl request up to 4 times with exponential backoff

API_KEY="bk_your_api_key"
MAX_RETRIES=4
BACKOFF=1

for attempt in $(seq 1 $MAX_RETRIES); do
  HTTP_STATUS=$(curl -s -o /tmp/response.json -w "%{http_code}" \
    -H "X-API-Key: $API_KEY" \
    "https://api.banklyze.com/v1/deals")

  if [ "$HTTP_STATUS" -eq 200 ]; then
    cat /tmp/response.json
    exit 0
  elif [ "$HTTP_STATUS" -eq 429 ]; then
    echo "Rate limited. Waiting ${BACKOFF}s before retry $attempt/$MAX_RETRIES..."
    sleep $BACKOFF
    BACKOFF=$((BACKOFF * 2))
  elif [ "$HTTP_STATUS" -ge 500 ]; then
    echo "Server error $HTTP_STATUS. Waiting ${BACKOFF}s..."
    sleep $BACKOFF
    BACKOFF=$((BACKOFF * 2))
  else
    echo "Non-retryable error: $HTTP_STATUS"
    cat /tmp/response.json
    exit 1
  fi
done

echo "Max retries exceeded"
exit 1

{
  "detail": "Validation failed",
  "code": "VALIDATION_ERROR",
  "errors": [
    {
      "loc": ["body", "business_name"],
      "msg": "Field required",
      "type": "missing"
    },
    {
      "loc": ["body", "funding_amount_requested"],
      "msg": "Input should be a valid number",
      "type": "float_parsing"
    }
  ]
}

HTTP/2 429
X-RateLimit-Limit: 120
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 1741132800
Content-Type: application/json

{
  "detail": "Rate limit exceeded. Try again in 23 seconds.",
  "code": "RATE_LIMIT_EXCEEDED",
  "errors": []
}

import os
import time
import requests

def check_rate_limit_headers(response: requests.Response) -> None:
    """Log rate limit status from response headers."""
    limit = response.headers.get("X-RateLimit-Limit")
    remaining = response.headers.get("X-RateLimit-Remaining")
    reset_ts = response.headers.get("X-RateLimit-Reset")

    if limit and remaining and reset_ts:
        reset_dt = time.strftime("%H:%M:%S", time.localtime(int(reset_ts)))
        print(f"Rate limit: {remaining}/{limit} remaining, resets at {reset_dt}")

        # Warn when running low
        if int(remaining) < 10:
            print("Warning: fewer than 10 requests remaining in this window")

resp = requests.get(
    "https://api.banklyze.com/v1/deals",
    headers={"X-API-Key": os.environ["BANKLYZE_API_KEY"]},
)
check_rate_limit_headers(resp)