Sebességkorlátozási (rate limit) hibák

Ha 429 Too Many Requests üzenetet látsz, akkor túl gyakran hívod az API-t. Így kezeld ezt helyesen.

Az error

HTTP 429 Too Many Requests
{
  "error": "Limit exceed."
}

Miért történik ez?

A sebességkorlátok (rate limit) megvédik az API-t a túlzott használattól:

• Túl sok kérés rövid idő alatt

• Agresszív lekérdezés (polling) vagy adatgyűjtés (scraping)

• Nincs késleltetés a kérések között

• Párhuzamos kérések korlátozás (throttling) nélkül

Exponenciális visszalépés (exponential backoff) stratégia

A sebességkorlátok kezelésének legjobb módja az exponenciális visszalépés: minden újrapróbálkozás után egyre hosszabb várakozás:

async function fetchWithBackoff(url, options, maxRetries = 5) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await fetch(url, options);
      
      if (response.status === 429) {
        const waitTime = Math.pow(2, attempt) * 1000; // 1s, 2s, 4s, 8s, 16s
        console.log(`Rate limited. Waiting ${waitTime}ms before retry ${attempt + 1}/${maxRetries}`);
        
        await new Promise(resolve => setTimeout(resolve, waitTime));
        continue;
      }
      
      if (!response.ok) {
        throw new Error(`HTTP ${response.status}`);
      }
      
      return await response.json();
      
    } catch (error) {
      if (attempt === maxRetries - 1) throw error;
    }
  }
  
  throw new Error('Max retries exceeded');
}

A sebességkorlátok megelőzése

Késleltess a kérések között:

// Rossz: gyors egymásutáni kérések
for (const id of mediaIds) {
  await api.getResource(id); // Nincs késleltetés
}
// Jó: korlátozott (throttled) kérések
for (const id of mediaIds) {
  await api.getResource(id);
  await sleep(500); // 500ms késleltetés
}

Végezd kötegekben (batch):

// Feldolgozás 10-as kötegekben késleltetésekkel
const batchSize = 10;
for (let i = 0; i < mediaIds.length; i += batchSize) {
  const batch = mediaIds.slice(i, i + batchSize);
  await Promise.all(batch.map(id => api.getResource(id)));
  
  if (i + batchSize < mediaIds.length) {
    await sleep(2000); // 2s késleltetés a kötegek között
  }
}

Cache-eld (gyorsítótárazd) a válaszokat:

const cache = new Map();
async function getCachedResource(mediaId) {
  if (cache.has(mediaId)) {
    return cache.get(mediaId);
  }
  
  const data = await api.getResource(mediaId);
  cache.set(mediaId, data);
  return data;
}

Mit NE tegyél

• ❌ Azonnal újrapróbálkozás késleltetés nélkül

• ❌ Korlátlanul párhuzamos kérések indítása

• ❌ A 429-es hibák figyelmen kívül hagyása

• ❌ Fix, rövid késleltetések használata (mindig exponenciális backoff-ot használj)

Ha továbbra is problémák vannak

Ha a felhasználási esetedhez valóban magasabb sebességkorlátokra van szükséged, vedd fel a kapcsolatot a fejlesztői támogatással. Add meg a következő részleteket:

• Az alkalmazásod és a felhasználási eseted

• Az elvárt kérésszám

• Jelenlegi megvalósítás (backoff-fal)