> ## Documentation Index
> Fetch the complete documentation index at: https://docs.livingsecurity.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Hastighedsbegrænsninger

> Anmodningsbudgetter for Living Security Public API, kontrakten for 429-svaret og sådan forsøger du igen med Retry-After.

API'et `/v1` håndhæver to uafhængige anmodningsbudgetter. En anmodning afvises,
hvis et af budgetterne er opbrugt.

| Budget | Gælder for |
| - | - |
| Pr. API-nøgle | Alle anmodninger, der præsenterer den pågældende nøgle, fra en hvilken som helst adresse |
| Pr. klient-IP | Alle anmodninger fra den pågældende adresse, uanset om de er godkendt eller ej |

Budgettet pr. nøgle følger nøglen, uanset hvor den bruges. Budgettet pr. IP er
det eneste budget for ikke-godkendt trafik og en ekstra grænse for godkendt
trafik.

<Note>
  Grænserne håndhæves før godkendelse, så anmodninger med ugyldige eller
  manglende legitimationsoplysninger tæller også med i kildens budget. De
  præcise talværdier konfigureres af operatøren og kan ændre sig; svarkontrakten
  nedenfor er den stabile grænseflade, som du bør bygge på.
</Note>

Godkend med en af de to Basic-legitimationsformer – se
[Quickstart](/da/developers/v1/quickstart) (`apikey:secret` eller `secret:`).
Sæt `BASE` til organisationens regionale vært – se
[Regioner](/da/developers/v1/regions).

## 429-svaret

Når et budget er opbrugt, returnerer API'et `429 Too Many Requests` med en
`Retry-After`-header (i sekunder) og den almindelige problem details-brødtekst:

```json 429 Too Many Requests theme={null}
{
  "type": "https://docs.livingsecurity.com/developers/v1/errors/rate_limited",
  "title": "Too Many Requests",
  "status": 429,
  "detail": "Rate limit exceeded. Retry after the Retry-After interval.",
  "code": "rate_limited",
  "request_id": "req_...",
  "doc_url": "https://docs.livingsecurity.com/developers/v1/errors/rate_limited",
  "retryable": true
}
```

Svaret oplyser ikke, hvilket budget der er opbrugt. Behandl alle `429`-svar
på samme måde: vent, og forsøg derefter igen.

## Håndtering af 429-svar

<Steps>
  <Step title="Respekter Retry-After">
    Vent mindst det antal sekunder, der er angivet i `Retry-After`-headeren, før du
    forsøger igen. Hvis du forsøger igen tidligere, bruger du blot budget på
    anmodninger, som alligevel bliver afvist.
  </Step>

  <Step title="Brug eksponentiel backoff ved gentagelser">
    Hvis et nyt forsøg afvises igen, skal du øge din backoff og tilføje tilfældig
    jitter, så parallelle workers ikke forsøger igen samtidigt. Forkort aldrig
    serverens `Retry-After` for at passe til en lokal grænse. Hvis serveren beder dig om at vente længere, end dit budget for nye forsøg tillader,
    skal du stoppe og planlægge opgaven til senere.
  </Step>

  <Step title="Udjævn din anmodningshastighed">
    Foretræk en jævn anmodningshastighed frem for byger af anmodninger. Ved
    masseindlæsning skal du bruge den maksimale sidestørrelse (`limit=500`) for at
    dække samlingen med færre anmodninger – se
    [paginering](/da/developers/v1/pagination). Når flere listegennemløb kører
    parallelt (for eksempel Power BI-tabeller), skal du holde samtidigheden moderat og respektere
    `Retry-After`, så et midlertidigt 429-svar ikke får hele opdateringen til at fejle.
  </Step>
</Steps>

Dette eksempel forsøger kun igen ved `429`-svar for en **GET**-anmodning, med
højst fem forsøg og højst 60 sekunders ventetid mellem forsøgene. Det stopper
straks ved andre fejl. Netværkstimeouts videregives til kalderen. Konfigurer
timeouts og budgetter for nye forsøg, så de passer til din arbejdsbyrde. `requests` fortolker
læsetimeouten som den maksimale inaktivitetstid under modtagelse af data, ikke
som en samlet tidsfrist.

Indlæs `LIVING_SECURITY_API_KEY` fra din secret manager. Installer `requests`,
før du kører dette eksempel. Kald `get_with_retry("/organization")` for at bruge det.

```python Python theme={null}
import os
import random
import time
import requests

# US: BASE = "https://api.us-east-1.livingsecurity.ai/v1"
BASE = "https://api.eu-west-1.livingsecurity.ai/v1"
AUTH = ("apikey", os.environ["LIVING_SECURITY_API_KEY"])

def get_with_retry(path, params=None, max_attempts=5):
    if not 1 <= max_attempts <= 5:
        raise ValueError("max_attempts must be between 1 and 5")
    for attempt in range(max_attempts):
        response = requests.get(
            f"{BASE}{path}", auth=AUTH, params=params,
            headers={"Living-Security-Version": "2026-07-01"},
            timeout=(5, 30), allow_redirects=False,
        )
        if response.status_code != 429:
            response.raise_for_status()
            if not 200 <= response.status_code < 300:
                raise RuntimeError("Unexpected redirect; check your regional API URL")
            return response

        # The API returns Retry-After as a whole number of seconds.
        raw_wait = response.headers.get("Retry-After", "")
        request_id = response.headers.get("Request-Id", "unknown")
        response.close()
        if attempt == max_attempts - 1:
            raise RuntimeError(f"Retry budget exhausted; request_id={request_id}")
        if not raw_wait.isascii() or not raw_wait.isdigit() or len(raw_wait) > 6:
            raise RuntimeError(f"Invalid Retry-After; request_id={request_id}")

        wait = max(int(raw_wait), min(2 ** attempt, 30))
        delay = wait + random.uniform(0, 1)
        if delay > 60:
            raise RuntimeError(f"Retry-After exceeds wait budget; request_id={request_id}")
        time.sleep(delay)
```

Kopiér ikke denne løkke rundt om en skriveoperation. En timeout efter en
skrivning kan betyde, at serveren nåede at gennemføre den, før forbindelsen
fejlede. Gentag kun en skrivning, når den pågældende operations reference
udtrykkeligt dokumenterer idempotens, og bevar i så fald den samme nøgle og
samme nyttelast. Ellers skal du afstemme ressourcens tilstand, før du prøver igen.

## Anbefalet opdateringsplan

Afstem opdateringsfrekvensen efter dit nøglebudget og din sidestørrelse. En
fuld historisk indlæsning af en stor samling er en engangsomkostning; foretræk
inkrementelle vinduer til opdateringer i jævn drift, så hver kørsel holder sig
et godt stykke under budgettet. Angiv altid
`limit=500` eksplicit – standardværdien på 25 øger antallet af anmodninger betydeligt.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.