Rate Limits | NueForm Docs

Die NueForm-API setzt Rate Limits durch, um faire Nutzung und die Stabilität der Plattform sicherzustellen. Die Limits gelten pro Benutzerkonto und basieren auf einem gleitenden Fenster von 60 Sekunden.

Limits nach Tarif

Tarif	Anfragen pro Minute	Fenster
Pro	100	60 Sekunden (gleitend)
Enterprise	500	60 Sekunden (gleitend)

Rate Limits gelten auf Kontoebene, nicht pro API-Schlüssel. Wenn du mehrere Schlüssel hast, teilen sie sich dasselbe Kontingent.

Rate-Limit-Header

Jede API-Antwort enthält Rate-Limit-Header, mit denen du deine Nutzung in Echtzeit überwachen kannst:

Header	Beschreibung	Beispiel
`X-RateLimit-Limit`	Maximal erlaubte Anfragen pro Fenster	`100`
`X-RateLimit-Remaining`	Verbleibende Anfragen im aktuellen Fenster	`87`
`X-RateLimit-Reset`	ISO-8601-Zeitstempel, wann das Fenster zurückgesetzt wird	`2026-02-28T14:30:45.000Z`

Beispiel für Antwort-Header:

text

HTTP/1.1 200 OK
Content-Type: application/json
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 87
X-RateLimit-Reset: 2026-02-28T14:30:45.000Z

Wenn du das Rate Limit erreichst

Wenn du dein Rate Limit überschreitest, gibt die API eine 429 Too Many Requests-Antwort zurück. Die Antwort enthält die üblichen Rate-Limit-Header sowie einen Retry-After-Header, der angibt, wie viele Sekunden du vor dem nächsten Versuch warten solltest.

Antwort

json

{
  "error": {
    "code": "RATE_LIMITED",
    "message": "Rate limit exceeded. Please try again later.",
    "status": 429
  }
}

Header einer 429-Antwort

text

HTTP/1.1 429 Too Many Requests
Content-Type: application/json
X-RateLimit-Limit: 100
X-RateLimit-Remaining: 0
X-RateLimit-Reset: 2026-02-28T14:31:12.000Z
Retry-After: 27

Der Retry-After-Wert ist die Anzahl der Sekunden, bis die älteste Anfrage in deinem aktuellen Fenster verfällt und wieder Kapazität frei wird.

Nutzung überwachen

Nutze die Rate-Limit-Header proaktiv, um das Limit gar nicht erst zu erreichen:

JavaScript

javascript

async function callApi(url, options = {}) {
  const response = await fetch(url, {
    ...options,
    headers: {
      "Authorization": `Bearer ${process.env.NUEFORM_API_KEY}`,
      "Content-Type": "application/json",
      ...options.headers,
    },
  });

  // Log rate limit status
  const remaining = response.headers.get("X-RateLimit-Remaining");
  const limit = response.headers.get("X-RateLimit-Limit");
  console.log(`Rate limit: ${remaining}/${limit} remaining`);

  if (response.status === 429) {
    const retryAfter = parseInt(response.headers.get("Retry-After"), 10);
    console.warn(`Rate limited. Retrying in ${retryAfter} seconds...`);
    await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));
    return callApi(url, options); // Retry
  }

  return response;
}

Python

python

import os
import time
import requests

API_KEY = os.environ["NUEFORM_API_KEY"]
BASE_URL = "https://app.nueform.com/api/v1"

def call_api(path, method="GET", **kwargs):
    url = f"{BASE_URL}{path}"
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
    }

    response = requests.request(method, url, headers=headers, **kwargs)

    # Log rate limit status
    remaining = response.headers.get("X-RateLimit-Remaining")
    limit = response.headers.get("X-RateLimit-Limit")
    print(f"Rate limit: {remaining}/{limit} remaining")

    if response.status_code == 429:
        retry_after = int(response.headers.get("Retry-After", 5))
        print(f"Rate limited. Retrying in {retry_after} seconds...")
        time.sleep(retry_after)
        return call_api(path, method, **kwargs)  # Retry

    return response

Best Practices

Implementiere exponentielles Backoff

Wenn du eine 429-Antwort erhältst, nutze exponentielles Backoff, statt sofort erneut anzufragen. Beginne mit dem Retry-After-Wert und erhöhe die Wartezeit mit jedem weiteren Versuch.

javascript

async function fetchWithBackoff(url, options = {}, maxRetries = 3) {
  for (let attempt = 0; attempt <= maxRetries; attempt++) {
    const response = await fetch(url, {
      ...options,
      headers: {
        "Authorization": `Bearer ${process.env.NUEFORM_API_KEY}`,
        "Content-Type": "application/json",
        ...options.headers,
      },
    });

    if (response.status !== 429) {
      return response;
    }

    if (attempt === maxRetries) {
      throw new Error("Max retries exceeded due to rate limiting");
    }

    const retryAfter = parseInt(
      response.headers.get("Retry-After") || "5",
      10
    );
    const backoff = retryAfter * Math.pow(2, attempt);
    console.warn(`Rate limited. Retry attempt ${attempt + 1} in ${backoff}s`);
    await new Promise((resolve) => setTimeout(resolve, backoff * 1000));
  }
}

Cache Antworten

Vermeide überflüssige API-Aufrufe, indem du Antworten lokal cachst. Formulardefinitionen und Theme-Konfigurationen ändern sich selten und eignen sich gut fürs Caching.

javascript

const cache = new Map();
const CACHE_TTL = 5 * 60 * 1000; // 5 minutes

async function getCachedForm(formId) {
  const cacheKey = `form_${formId}`;
  const cached = cache.get(cacheKey);

  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    return cached.data;
  }

  const response = await fetch(
    `https://app.nueform.com/api/v1/forms/${formId}`,
    {
      headers: {
        "Authorization": `Bearer ${process.env.NUEFORM_API_KEY}`,
      },
    }
  );

  const { data } = await response.json();
  cache.set(cacheKey, { data, timestamp: Date.now() });
  return data;
}

Nutze Webhooks für Echtzeitdaten

Statt die API laufend nach neuen Formularantworten abzufragen, richte Webhooks ein, um bei eingehenden Übermittlungen benachrichtigt zu werden. Das erspart dir wiederholtes Polling und liefert die Daten schneller.

Bündle Operationen, wo möglich

Wenn du mehrere Ressourcen abrufen musst, verwende Listen-Endpunkte mit Paginierung statt einzelner Anfragen pro Ressource. Ein einziger Aufruf von

GET/api/v1/forms?per_page=100

ist deutlich effizienter als 100 separate Aufrufe.

Behalte den `X-RateLimit-Remaining`-Header im Blick

Verfolge dein verbleibendes Kontingent und drossle deine Anfragen, bevor du das Limit erreichst. Fällt X-RateLimit-Remaining unter 10, füge am besten eine kurze Pause zwischen den Anfragen ein.

Rate Limits schützen die Plattform für alle Nutzer. Anwendungen, die die Limits dauerhaft überschreiten oder zu umgehen versuchen, können vom API-Zugriff ausgeschlossen werden. Wenn du höhere Limits brauchst, ziehe ein Upgrade auf den Enterprise-Tarif in Betracht oder kontaktiere den Support.

Dein Rate Limit erhöhen

Wenn du mehr als 100 Anfragen pro Minute brauchst, wechsle zum Enterprise-Tarif mit 500 Anfragen pro Minute. Für Limits jenseits von Enterprise kontaktiere unser Sales-Team, um individuelle Vereinbarungen zu besprechen.

Tarif	Rate Limit	Preis
Pro	100 Anfragen/min	29 $/Monat
Enterprise	500 Anfragen/min	99 $/Monat
Custom	Verhandelbar	Sales kontaktieren