Rate Limits

import { Grantex } from '@grantex/sdk';

const client = new Grantex({ apiKey: 'gx_...' });
const agents = await client.agents.list();

const rl = client.lastRateLimit;
if (rl) {
  console.log(`${rl.remaining}/${rl.limit} requests left, resets at ${rl.reset}`);
}

from grantex import Grantex

client = Grantex(api_key="gx_...")
agents = client.agents.list()

rl = client.last_rate_limit
if rl:
    print(f"{rl.remaining}/{rl.limit} requests left, resets at {rl.reset}")

client := grantex.NewClient("gx_...")
agents, _ := client.Agents.List(ctx)

if rl := client.LastRateLimit(); rl != nil {
    fmt.Printf("%d/%d requests left, resets at %d\n", rl.Remaining, rl.Limit, rl.Reset)
}

import { GrantexApiError } from '@grantex/sdk';

try {
  await client.tokens.verify(token);
} catch (err) {
  if (err instanceof GrantexApiError && err.rateLimit?.retryAfter) {
    console.log(`Rate limited — retry in ${err.rateLimit.retryAfter}s`);
  }
}

from grantex import GrantexApiError

try:
    client.tokens.verify(token)
except GrantexApiError as err:
    if err.rate_limit and err.rate_limit.retry_after:
        print(f"Rate limited — retry in {err.rate_limit.retry_after}s")

var apiErr *grantex.APIError
if errors.As(err, &apiErr) && apiErr.RateLimit != nil && apiErr.RateLimit.RetryAfter > 0 {
    fmt.Printf("Rate limited — retry in %ds\n", apiErr.RateLimit.RetryAfter)
}

import { GrantexApiError } from '@grantex/sdk';

async function withRetry<T>(fn: () => Promise<T>, maxRetries = 3): Promise<T> {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    try {
      return await fn();
    } catch (err: unknown) {
      if (!(err instanceof GrantexApiError) || err.statusCode !== 429 || attempt === maxRetries) throw err;

      const base = (err.rateLimit?.retryAfter ?? 2 ** attempt) * 1000;
      const jitter = Math.random() * 500;
      await new Promise((r) => setTimeout(r, base + jitter));
    }
  }
  throw new Error('Unreachable');
}

import time
import random
from grantex import GrantexApiError

def with_retry(fn, max_retries=3):
    for attempt in range(max_retries + 1):
        try:
            return fn()
        except GrantexApiError as err:
            if err.status_code != 429 or attempt == max_retries:
                raise

            base = float(err.rate_limit.retry_after if err.rate_limit and err.rate_limit.retry_after else 2 ** attempt)
            jitter = random.uniform(0, 0.5)
            time.sleep(base + jitter)

package main

import (
	"errors"
	"math"
	"math/rand"
	"time"

	grantex "github.com/mishrasanjeev/grantex-go"
)

func withRetry[T any](fn func() (T, error), maxRetries int) (T, error) {
	var zero T
	for attempt := 0; attempt <= maxRetries; attempt++ {
		result, err := fn()
		if err == nil {
			return result, nil
		}

		var apiErr *grantex.APIError
		if !errors.As(err, &apiErr) || apiErr.StatusCode != 429 || attempt == maxRetries {
			return zero, err
		}

		base := math.Pow(2, float64(attempt))
		if apiErr.RateLimit != nil && apiErr.RateLimit.RetryAfter > 0 {
			base = float64(apiErr.RateLimit.RetryAfter)
		}
		jitter := rand.Float64() * 0.5
		time.Sleep(time.Duration((base+jitter)*1000) * time.Millisecond)
	}
	return zero, errors.New("unreachable")
}