Rate Limits

💬

Hallo, ich bin Sophie! 👋 Lass mich Ihnen erklären, wie unsere Rate Limits funktionieren. Diese Limits stellen sicher, dass unsere API für alle Nutzer zuverlässig und schnell bleibt - auch wenn viele Anfragen gleichzeitig eingehen.

⏱️

Warum Rate Limits? Stell Ihnen eine Autobahn vor: Wenn zu viele Autos gleichzeitig fahren, kommt es zum Stau. Rate Limits sind wie Ampeln, die den Verkehr regeln und dafür sorgen, dass alle vorankommen.

Limits nach Tarif

Je nach Ihrem Tarif gelten unterschiedliche Limits:

Tarif	Anfragen pro Minute	Anfragen pro Tag	Burst-Limit
Starter	60	1.000	10
Pro	300	10.000	50
Business	600	50.000	100
Enterprise	Individuell	Individuell	Individuell

Was bedeuten diese Zahlen?

Anfragen pro Minute: Wie viele API-Aufrufe Sie innerhalb von 60 Sekunden machen können
Anfragen pro Tag: Ihr tägliches Gesamtkontingent (zurückgesetzt um Mitternacht MEZ)
Burst-Limit: Maximale Anzahl gleichzeitiger Anfragen in einer Sekunde

💡

Sophie’s Tipp: Für die meisten Integrationen sind die Starter-Limits völlig ausreichend. Selbst 60 Anfragen pro Minute bedeuten, dass Sie jede Sekunde eine Rechnung erstellen oder abrufen könntest - das schafft kaum jemand manuell!

Rate Limit Headers

Bei jeder API-Antwort erhältst Sie Informationen über Ihren aktuellen Status:


HTTP/1.1 200 OK
X-RateLimit-Limit: 300
X-RateLimit-Remaining: 287
X-RateLimit-Reset: 1704067200

Header	Beschreibung
`X-RateLimit-Limit`	Ihr Limit pro Minute
`X-RateLimit-Remaining`	Verbleibende Anfragen in diesem Zeitfenster
`X-RateLimit-Reset`	Unix-Timestamp, wann das Limit zurückgesetzt wird

Was passiert bei Überschreitung?

Wenn Sie das Limit überschreitest, erhältst Sie einen HTTP-Statuscode 429 Too Many Requests:


{
  "error": {
    "code": "RATE_LIMIT_EXCEEDED",
    "message": "Anfragelimit überschritten. Bitte warte und versuche es erneut.",
    "details": {
      "retry_after": 32,
      "limit": 300,
      "reset_at": "2026-01-10T15:30:00Z"
    }
  }
}

Der Retry-After Header zeigt Ihnen, wie viele Sekunden Sie warten solltest:


HTTP/1.1 429 Too Many Requests
Retry-After: 32

Best Practices

1. Exponentielles Backoff implementieren

Wenn Sie einen 429 Fehler erhältst, warte nicht einfach eine feste Zeit. Verdopple stattdessen die Wartezeit bei jedem Versuch:


async function fetchWithRetry(url: string, options: RequestInit, maxRetries = 3) {
  let lastError: Error | null = null;
 
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      const response = await fetch(url, options);
 
      if (response.status === 429) {
        const retryAfter = parseInt(response.headers.get('Retry-After') || '1');
        const waitTime = retryAfter * 1000 * Math.pow(2, attempt);
 
        console.log(`Rate limit erreicht. Warte ${waitTime}ms...`);
        await new Promise(resolve => setTimeout(resolve, waitTime));
        continue;
      }
 
      return response;
    } catch (error) {
      lastError = error as Error;
    }
  }
 
  throw lastError || new Error('Max retries exceeded');
}

2. Anfragen bündeln

Statt viele einzelne Anfragen zu senden, nutze Batch-Endpunkte wo verfügbar:


// Ineffizient: 100 einzelne Anfragen
for (const customerId of customerIds) {
  await fetch(`/v1/customers/${customerId}`);
}
 
// Effizient: 1 Batch-Anfrage
await fetch('/v1/customers/batch', {
  method: 'POST',
  body: JSON.stringify({ ids: customerIds }),
});

💡

Sophie’s Tipp: Unser /batch Endpunkt erlaubt bis zu 100 Ressourcen pro Anfrage. Das spart nicht nur Rate Limit, sondern ist auch schneller, weil Sie auf weniger Netzwerk-Roundtrips warten musst.

3. Caching nutzen

Speichere Daten lokal zwischen, die sich selten ändern:


const cache = new Map<string, { data: any; expires: number }>();
 
async function getCachedData(key: string, fetcher: () => Promise<any>, ttlSeconds = 300) {
  const cached = cache.get(key);
 
  if (cached && cached.expires > Date.now()) {
    return cached.data;
  }
 
  const data = await fetcher();
  cache.set(key, { data, expires: Date.now() + ttlSeconds * 1000 });
 
  return data;
}
 
// Beispiel: Kundendaten 5 Minuten cachen
const customer = await getCachedData(
  `customer:${customerId}`,
  () => fetch(`/v1/customers/${customerId}`).then(r => r.json())
);

4. Rate Limit überwachen

Prüfe regelmäßig die X-RateLimit-Remaining Header:


const response = await fetch('/v1/invoices');
const remaining = parseInt(response.headers.get('X-RateLimit-Remaining') || '0');
 
if (remaining < 10) {
  console.warn(`Warnung: Nur noch ${remaining} Anfragen übrig!`);
  // Optional: Benachrichtigung senden oder Anfragen drosseln
}

Spezielle Limits

Einige Endpunkte haben zusätzliche Limits:

Endpunkt	Spezielles Limit	Grund
`/v1/sophie/chat`	50/Stunde	KI-Rechenressourcen
`/v1/invoices/bulk`	10/Minute	Große Datenmengen
`/v1/reports/generate`	5/Stunde	Intensive Berechnungen

⚠️

Wichtig: Diese speziellen Limits werden separat gezählt und sind im X-RateLimit-* Header des jeweiligen Endpunkts sichtbar.

Enterprise: Individuelle Limits

Für Enterprise-Kunden bieten wir maßgeschneiderte Limits:

Höhere Anfragen pro Minute - Bis zu 6.000 oder mehr
Höhere Tageslimits - Unbegrenzt nach Absprache
Dedicated Infrastructure - Eigene API-Server für maximale Performance
Priority Queue - Ihre Anfragen werden bevorzugt bearbeitet

Kontaktiere office@buchhaltgenie.at für ein individuelles Angebot.

Häufige Fragen

Kann ich mein Rate Limit erhöhen?

Ja! Durch ein Upgrade auf einen höheren Tarif erhältst Sie automatisch höhere Limits. Für Enterprise-Kunden können wir individuelle Limits vereinbaren.

Was zählt als eine Anfrage?

Jeder API-Aufruf zählt als eine Anfrage, unabhängig davon, ob er erfolgreich war oder nicht. Auch 404 oder 400 Fehler werden gezählt. Nur bei 429 Fehlern (Rate Limit überschritten) wird keine zusätzliche Anfrage gezählt.

Wie werden Batch-Anfragen gezählt?

Eine Batch-Anfrage zählt als eine einzelne Anfrage, unabhängig davon, wie viele Ressourcen sie enthält. Das macht Batch-Anfragen besonders effizient für Ihre Rate Limits.

Was passiert um Mitternacht?

Das tägliche Limit wird um 00:00 Uhr MEZ zurückgesetzt. Das Minutenlimit wird kontinuierlich rollierend berechnet - jede Anfrage “verfällt” nach 60 Sekunden.

Nächste Schritte

Authentifizierung - Sicherer API-Zugang
Sicherheit - Best Practices für sichere Integrationen
API Endpunkte - Starte mit der Integration

⚖️

Hinweis: Die Rate Limits dienen dem Schutz aller Nutzer. Bei wiederholtem, absichtlichem Überschreiten behalten wir uns vor, den API-Zugang einzuschränken.