Error Handling

async function fetchProfile(profileUrl, apiKey) {
  const response = await fetch(
    `https://api.fetchin.io/api/v1/profile?profileUrlOrUrn=${encodeURIComponent(profileUrl)}`,
    { headers: { 'X-API-Key': apiKey } },
  );

  if (response.ok) return response.json();

  const { error, code } = await response.json();

  switch (code) {
    case 'MISSING_PARAMETER':
    case 'INVALID_PARAMETER':
    case 'INVALID_URN':
      throw new Error(`Bad request: ${error}`); // fix the request
    case 'INVALID_API_KEY':
    case 'UNAUTHENTICATED':
      throw new Error(`Auth: ${error}`);
    case 'QUOTA_EXHAUSTED':
      // Both balances are empty: buy credits or upgrade the plan.
      throw new Error('Out of credits — buy more or upgrade your plan.');
    case 'PROFILE_NOT_FOUND':
    case 'POST_NOT_FOUND':
    case 'COMPANY_NOT_FOUND':
      return null; // genuinely not found — don't retry
    default:
      throw new Error(`${code}: ${error}`);
  }
}

async function fetchWithRetry(url, options, maxRetries = 4) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const response = await fetch(url, options);

    // 503 (our capacity) and 429 (rate limit) are safe to retry.
    if (response.status === 503 || response.status === 429) {
      const retryAfter = Number(response.headers.get('Retry-After')) || 2 ** attempt;
      await new Promise((r) => setTimeout(r, retryAfter * 1000));
      continue;
    }

    if (response.status === 500 && attempt < maxRetries - 1) {
      await new Promise((r) => setTimeout(r, 2 ** attempt * 1000));
      continue;
    }

    return response;
  }
  throw new Error('Exhausted retries');
}

import requests

def fetch_profile(profile_url, api_key):
    resp = requests.get(
        'https://api.fetchin.io/api/v1/profile',
        headers={'X-API-Key': api_key},
        params={'profileUrlOrUrn': profile_url},
    )
    if resp.ok:
        return resp.json()

    body = resp.json()
    code = body.get('code')

    if code in ('MISSING_PARAMETER', 'INVALID_PARAMETER', 'INVALID_URN'):
        raise ValueError(body['error'])          # fix the request
    if code == 'QUOTA_EXHAUSTED':
        # Both balances are empty: buy credits or upgrade the plan.
        raise RuntimeError('Out of credits — buy more or upgrade your plan.')
    if code in ('PROFILE_NOT_FOUND', 'POST_NOT_FOUND', 'COMPANY_NOT_FOUND'):
        return None                                # not found — don't retry
    raise RuntimeError(f"{code}: {body['error']}")

import time, requests

def fetch_with_retry(url, headers, params, max_retries=4):
    for attempt in range(max_retries):
        resp = requests.get(url, headers=headers, params=params)
        # 503 (our capacity) and 429 (rate limit) are safe to retry.
        if resp.status_code in (503, 429):
            retry_after = int(resp.headers.get('Retry-After', 2 ** attempt))
            time.sleep(retry_after)
            continue
        if resp.status_code == 500 and attempt < max_retries - 1:
            time.sleep(2 ** attempt)
            continue
        return resp
    raise RuntimeError('Exhausted retries')