---
title: "HTTP 499 Client Closed Request: Ursachen und Lösungen"
description: "HTTP 499 heißt: Der Client hat die Verbindung geschlossen, bevor der Server antwortete. Warum nginx und Cloudflare ihn protokollieren und welches Timeout hilft."
url: https://proxynet.io/de/blog/http-499-error
date: 2026-11-19
author: "Acar Diveroli"
category: "Anleitungen"
lang: de
---

# HTTP 499 Client Closed Request: Ursachen und Lösungen

Ein Kunde schreibt, der monatliche Umsatzbericht „lädt nur und öffnet sich nie“. Es gibt keine Fehlerseite und nichts im Fehlerprotokoll der Anwendung. Im Zugriffsprotokoll (Access-Log) von nginx endet die Zeile für diese Anfrage mit einem Status, den Sie in keinem Browser finden: `499`, null gesendete Bytes und eine Anfragedauer von genau 30 Sekunden. Der Server hat nicht versagt. Jemand hat aufgehört zu warten.

Im Folgenden: was der Code 499 bedeutet und wer ihn sieht, die üblichen Ursachen, wie Sie ihn in Ihren Protokollen lesen, wie Sie ihn auf dem Server beheben, was Cloudflare und Load Balancer melden und was Sie prüfen, wenn der Client, der aufgegeben hat, Ihr eigenes Skript hinter einem Proxy ist.

> **Hinweis: Kurzantwort**
>
> HTTP 499 „Client Closed Request“ ist ein Code, den nginx in sein Zugriffsprotokoll schreibt, wenn der Client die Verbindung schließt, bevor nginx eine Antwort gesendet hat. Er gehört nicht zum HTTP-Standard und wird nie an jemanden geschickt: Der Browser oder das Skript, das aufgelegt hat, sieht sein eigenes Timeout oder gar nichts. Die übliche Ursache ist ein Client, ein Load Balancer oder ein Monitor, dessen Timeout kürzer ist als die Zeit, die der Server braucht. Die Lösung: herausfinden, wer die Verbindung geschlossen hat, die langsame Anfrage beschleunigen oder in einen Hintergrundjob verlagern und jedes Timeout länger einstellen als das der Schicht dahinter.

## Was bedeutet HTTP 499?

HTTP 499 bedeutet, dass der Client eine Anfrage aufgegeben hat, bevor der Server antwortete. Client ist, wer die Verbindung geöffnet hat: ein Browser, eine Mobile-App, ein Skript oder ein anderer Server wie ein Load Balancer. Der Code sagt nichts darüber, ob die Anfrage gültig war oder ob die Antwort richtig gewesen wäre.

Der Name stammt aus dem Quellcode von nginx. In der Datei, die seine Statuscodes definiert, [erklären die nginx-Entwickler](https://github.com/nginx/nginx/blob/master/src/http/ngx_http_request.h), dass HTTP keinen Code für einen Client kennt, der die Verbindung schließt, während seine Anfrage noch verarbeitet wird; deshalb führten sie einen eigenen ein, `NGX_HTTP_CLIENT_CLOSED_REQUEST`, mit der Nummer 499. Der Kommentar beschränkt ihn auf Clients, die gehen, bevor nginx überhaupt versucht, den Antwort-Header zu senden.

## Ist 499 ein offizieller HTTP-Statuscode?

Nein. Das [IANA-Verzeichnis der HTTP-Statuscodes](https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml), die offizielle Liste hinter dem HTTP-Standard, führt den ganzen Bereich von 452 bis 499 als nicht vergeben. 499 gehört zu einer kleinen Gruppe, die nginx für seine eigenen Protokolle verwendet, neben 494 (Anfrage-Header zu groß), 495 und 496 (Probleme mit dem Client-Zertifikat) und 497 (unverschlüsseltes HTTP an einen HTTPS-Port). Anders als ein echter 4xx-Code wie 404 oder 429 ist er ein Protokolleintrag, keine Antwort: Kein Client bekommt ihn je.

## Wer sieht einen 499-Fehler?

Nur der Betreiber des Servers, im Zugriffsprotokoll oder in Auswertungen, die auf Protokollen beruhen. Jede Seite hält denselben Moment auf ihre eigene Weise fest:

| Wer | Was er sieht | Wo |
|---|---|---|
| Browser-Nutzer | Ein Ladesymbol, das stehen bleibt, oder nichts | Auf der Seite selbst |
| curl | `curl: (28) Operation timed out` | Terminal, Exit-Code 28 |
| Python Requests | Ausnahme `ReadTimeout` | Ausgabe des Skripts |
| nginx-Betreiber | Status 499, oft 0 Bytes | Zugriffsprotokoll |

Wir haben das auf unserem Testrechner mit einem winzigen Node.js-Server auf 127.0.0.1 nachgestellt, der jede Anfrage nach fünf Sekunden beantwortet. `curl --max-time 2` gab mit `Operation timed out after 2007 milliseconds with 0 bytes received` und Exit-Code 28 auf, den libcurl als Timeout einer Operation definiert; im selben Moment hielt der Server fest, dass der Client die Verbindung vor der Antwort geschlossen hatte, also genau das Ereignis, das nginx als 499 protokolliert. Mit `--max-time 8` kam dieselbe Anfrage nach 5,0 Sekunden mit 200 zurück.

## Wie entsteht ein 499, Schritt für Schritt?

1. **Der Client sendet eine Anfrage** und startet seinen eigenen Timer: Ein Browser wartet so lange wie der Nutzer, ein Skript so lange, wie sein Timeout erlaubt.
2. **nginx nimmt sie an und reicht sie weiter** an die Anwendung dahinter.
3. **Die Antwort dauert länger, als der Client wartet:** eine schwere Datenbankabfrage, ein kalter Cache, eine langsame API eines Drittanbieters.
4. **Der Client schließt die Verbindung.** Der Nutzer wechselt die Seite, das Timeout des Skripts schlägt zu oder ein vorgeschalteter Load Balancer bricht die Anfrage ab.
5. **nginx bemerkt die geschlossene Verbindung**, schließt standardmäßig auch seine Verbindung zur Anwendung und protokolliert die Anfrage mit Status 499.

Ob die Anwendung in Schritt 5 aufhört, hängt von der Anwendung ab. Viele Frameworks bemerken die geschlossene Verbindung erst, wenn sie die Antwort schreiben wollen; die teure Abfrage läuft also womöglich bis zum Ende, und ihr Ergebnis wird verworfen.

## Was verursacht HTTP 499?

Fast jeder 499 ist ein unpassendes Timeout oder ein Mensch, der aufgehört hat zu warten. Prüfen Sie die Ursachen ungefähr in dieser Reihenfolge:

- **Ein Client-Timeout, das kürzer ist als die Antwortzeit des Servers.** Eine App, die 10 Sekunden auf einen Endpoint wartet, der 12 braucht, erzeugt einen stetigen Strom von 499ern.
- **Menschen, die die Seite verlassen:** einen Tab schließen, auf Stopp drücken oder wegklicken, bevor die Seite geladen ist.
- **Ein Load Balancer, ein CDN oder ein Proxy vor nginx** mit einem kürzeren Timeout. nginx protokolliert dann die Adresse dieser Zwischenschicht als Client.
- **Mobilfunknetze.** Ein Smartphone, das vom WLAN zu mobilen Daten wechselt, verliert die Verbindung mitten in der Anfrage.
- **Health Checks und Monitore**, die zwei Sekunden auf eine Seite warten, die drei braucht.
- **Skripte und Crawler** mit knappen Timeouts, auch Ihre eigenen Jobs über einen Proxy.
- **Abbruch durch die App selbst.** Ein Suchfeld bricht die vorige Anfrage ab, wenn der Nutzer den nächsten Buchstaben tippt.

## Worin unterscheidet sich 499 von 408, 502 und 504?

Der Unterschied liegt darin, wer aufgegeben hat und ob eine Antwort gesendet wurde. 499 ist in dieser Gruppe der einzige Code, den niemand erhält:

| Code | Wer hat aufgegeben | An den Client gesendet? | Übliche Lösung |
|---|---|---|---|
| `499` | Der Client | Nein, nur im Protokoll | Schnellerer Upstream, längeres Client-Timeout |
| `408` | Der Server, beim Warten auf die Anfrage | Ja | Der Client muss schneller senden |
| `502` | Das Gateway bekam eine fehlerhafte Antwort | Ja | Die abgestürzte Anwendung reparieren |
| `504` | Das Gateway hat zu lange gewartet | Ja | Schnellerer Upstream, längeres Gateway-Timeout |

Ein 499 und ein 504 haben oft dieselbe Ursache, einen langsamen Upstream: Läuft zuerst der Timer des Clients ab, sehen Sie 499; läuft der von nginx ab, bekommt der Client einen 504. Eine fehlerhafte Antwort der Anwendung ist ein 502, beschrieben in [502 Bad Gateway: Bedeutung und Lösung des Fehlers](/de/blog/502-bad-gateway).

## Wie lesen Sie 499 in den nginx-Protokollen?

Ergänzen Sie das Zugriffsprotokoll um Zeitfelder und sehen Sie dann nach, wie lange der Client vor jedem 499 gewartet hat. Das Standardformat `combined` von nginx hält den Status fest, aber nicht die Dauer; beginnen Sie also mit einem eigenen Format:

```nginx
log_format timed '$remote_addr - [$time_local] "$request" $status $body_bytes_sent '
                 'rt=$request_time urt=$upstream_response_time us=$upstream_status '
                 '"$http_user_agent"';
access_log /var/log/nginx/access.log timed;
```

`$request_time` ist die Zeit vom ersten Byte, das nginx vom Client gelesen hat, bis zu dem Moment, in dem es die Protokollzeile schreibt, in Sekunden mit Millisekunden-Auflösung. `$upstream_response_time` ist die Zeit, die der Empfang der Antwort von der Anwendung gedauert hat, und `$upstream_status` der Status, den die Anwendung zurückgegeben hat. Eine 499-Zeile in diesem Format könnte so aussehen (Beispielwerte):

```text
203.0.113.7 - [19/Nov/2026:10:42:13 +0000] "GET /reports/monthly HTTP/1.1" 499 0 rt=30.001 urt=30.000 us=- "ExampleApp/2.1"
```

Drei Fragen beantworten das meiste:

1. **Häufen sich die 499er bei einem Wert?** Steht bei `rt` über Hunderte Zeilen `30.001`, `30.002` und `29.999`, hat irgendein Client ein Timeout von 30 Sekunden. Verstreute Werte deuten auf Menschen, die die Seite verlassen.
2. **Wer ist der Client?** Adresse und User-Agent unterscheiden einen Browser von einer Mobile-App, Ihrem Load Balancer oder einem Überwachungsdienst.
3. **Wie lange braucht der Endpoint normalerweise?** Sehen Sie sich `urt` bei den erfolgreichen Anfragen an dieselbe URL an. Dauern sie oft länger als der gehäufte 499-Wert, ist der Endpoint für diesen Client zu langsam. In der 499-Zeile bedeutet `us=-`, dass die Anwendung noch keinen Status gesendet hatte.

Hinter einem Load Balancer steht in `$remote_addr` auf jeder Zeile die Adresse des Load Balancers; protokollieren Sie auch die weitergeleitete Client-Adresse, sonst sieht jeder 499 so aus, als käme er von einem einzigen Rechner.

## Wie beheben Sie HTTP 499 auf dem Server?

Beheben Sie zuerst die langsame Anfrage und dann die Timeouts; ein längeres Timeout verschiebt das Warten nur an eine andere Stelle.

1. **Finden Sie heraus, wer die Verbindung geschlossen hat**, mit den Protokollfeldern von oben. Ein gehäufter Wert von Ihrem Load Balancer ist eine Frage der Konfiguration; verstreute Werte von Browsern sind ein Geschwindigkeitsproblem.
2. **Machen Sie den langsamen Endpoint schneller:** das Ergebnis cachen, den fehlenden Index anlegen, eine riesige Antwort auf Seiten aufteilen.
3. **Machen Sie aus langen Aufgaben Hintergrundjobs.** Antworten Sie sofort mit einer Job-ID (dafür gibt es den Status 202 Accepted) und lassen Sie den Client wieder nachfragen, wenn der Bericht fertig ist.
4. **Stimmen Sie die Timeouts von außen nach innen ab.** Jede Schicht sollte etwas länger warten als die Schicht dahinter: Client, dann CDN oder Load Balancer, dann nginx, dann die Anwendung. `proxy_read_timeout` von nginx ist die Wartezeit zwischen zwei Lesevorgängen von der Anwendung, keine Grenze für die ganze Antwort, und steht standardmäßig auf 60 Sekunden ([nginx-Proxy-Modul](https://nginx.org/en/docs/http/ngx_http_proxy_module.html#proxy_read_timeout)).
5. **Nutzen Sie `proxy_ignore_client_abort` nur mit gutem Grund.** Die standardmäßig ausgeschaltete Direktive entscheidet, ob nginx seine Verbindung zur Anwendung schließt, wenn der Client geht. Eingeschaltet lässt sie Arbeit zu Ende laufen, die fertig werden muss, etwa das Befüllen eines Caches; dafür kostet dann jede verlassene Anfrage die volle Serverzeit.
6. **Lassen Sie 499 in der Überwachung sichtbar, aber getrennt.** Ein paar 499er sind auf jeder stark besuchten Website normal; ein plötzlicher Anstieg bei einer URL ist ein frühes Zeichen, dass sie langsam geworden ist.

## Was bedeutet 499 bei Cloudflare und Load Balancern?

Bei Cloudflare bedeutet 499 dasselbe: Der Client hat die Verbindung geschlossen, bevor die Anfrage abgeschlossen war. Die [Cloudflare-Dokumentation zu Fehler 499](https://developers.cloudflare.com/support/troubleshooting/http-status-codes/4xx-client-error/error-499/) stellt fest, dass keine 499-Antwort an den Client geht und der Code nur in Protokollen erscheint. Als Ursachen nennt sie knappe Fristen beim Client, langsame Ursprungsserver und eine sinkende Cache-Trefferquote, und sie empfiehlt, die 499-Rate mit allen Anfragen an denselben Endpoint zu vergleichen. Seit dem 19. Januar 2026 protokolliert Cloudflare auch abgebrochene HTTP/3-Anfragen als 499; Websites sehen deshalb bei HTTP/3-Verkehr womöglich mehr davon.

Andere Load Balancer verwenden für dasselbe Ereignis eigene Nummern. Der Application Load Balancer von AWS protokolliert HTTP 460, wenn der Client die Verbindung schließt, bevor das Leerlauf-Timeout (Idle Timeout) des Load Balancers abgelaufen ist, und sein [Leitfaden zur Fehlerbehebung](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/load-balancer-troubleshooting.html#http-460-issues) gibt denselben Rat: vor dem Timeout des Clients antworten oder das Timeout des Clients passend erhöhen.

## Wenn Sie der Client sind: 499 durch Ihr eigenes Skript

Sagt Ihnen der Betreiber einer Website, dass Ihre Anfragen als 499 erscheinen, hat Ihr Skript aufgelegt, bevor sein Server antwortete. Die Lösung gehört in Ihren Code.

HTTP-Bibliotheken teilen das Timeout meist in zwei: Das Verbindungs-Timeout begrenzt, wie lange das Skript auf den Verbindungsaufbau wartet, das Lese-Timeout, wie lange es nach dem Absenden der Anfrage auf Daten wartet. Die Python-Bibliothek Requests setzt keines von beiden, wenn Sie es nicht tun; ein Skript kann also minutenlang hängen, während ein sehr kurzes Lese-Timeout auf jeder langsamen Seite einen 499 hinterlässt.

Das Beispiel unten wartet bei jedem Versuch länger, statt wieder an derselben Stelle aufzulegen. Wir haben es gegen denselben lokalen Testserver laufen lassen (Python 3.13, Requests 2.34):

```python
import time

import requests

URL = "http://127.0.0.1:18499/report"  # unser lokaler Testserver; er antwortet nach 5 Sekunden
PROXIES = None  # oder {"http": "http://user:pass@pr.proxynet.io:8000", "https": "http://user:pass@pr.proxynet.io:8000"}
CONNECT = 5  # Sekunden für den Verbindungsaufbau
READ_TIMEOUTS = (2, 4, 8)  # jeder neue Versuch wartet länger, statt an derselben Stelle aufzulegen

def fetch(url):
    for attempt, read in enumerate(READ_TIMEOUTS, start=1):
        started = time.monotonic()
        try:
            r = requests.get(url, proxies=PROXIES, timeout=(CONNECT, read))
            print(f"attempt {attempt}: HTTP {r.status_code} after {time.monotonic() - started:.1f} s")
            return r
        except requests.exceptions.ReadTimeout:
            # Hier legen wir auf; ein Server mit nginx protokolliert diese Anfrage als 499.
            print(f"attempt {attempt}: no answer within {read} s, closed the connection")
        except requests.exceptions.ConnectTimeout:
            print(f"attempt {attempt}: could not connect within {CONNECT} s")
        time.sleep(1)
    raise RuntimeError(f"{url}: no answer within {READ_TIMEOUTS[-1]} s, check the server side")

fetch(URL)
```

Ausgabe:

```text
attempt 1: no answer within 2 s, closed the connection
attempt 2: no answer within 4 s, closed the connection
attempt 3: HTTP 200 after 5.0 s
```

Der Server verzeichnete die ersten beiden Versuche nach 2,0 und 4,0 Sekunden als vom Client geschlossen und den dritten als normalen 200. Wiederholen Sie auf diese Weise nur Anfragen, die nichts verändern, etwa GET: Ein POST, der in ein Timeout lief, wurde womöglich trotzdem verarbeitet. Ist eine Seite für alle langsam, senken Sie Ihre Anfragerate. Wie ein Crawler mit den anderen Codes umgehen sollte, auf die er stößt, steht in [HTTP-Statuscodes beim Web Scraping: 403, 407, 429, 503](/de/blog/http-status-codes-web-scraping).

## Verursacht ein Proxy 499-Fehler?

Ein Proxy erzeugt keine 499er, aber er fügt Zeit hinzu, die Ihr Timeout abdecken muss: Jede Anfrage läuft zum Proxy und weiter zum Ziel, und ein Ausgang weit vom Ziel entfernt verlängert jeden Hin- und Rückweg. Ein Lese-Timeout, das für direkte Anfragen eingestellt wurde, kann dann zu knapp sein, und das Ziel protokolliert einen 499 mit der Ausgangsadresse des Proxys als Client.

Messen Sie, bevor Sie etwas ändern: `curl -w` mit `%{time_connect}` und `%{time_starttransfer}` zeigt, wie lange Verbindung und erstes Byte mit und ohne Proxy dauern. Stellen Sie das Timeout nach diesen Zahlen ein, mit Spielraum für langsame Seiten. Für lange Jobs gegen wenige bekannte Websites gibt Ihnen ein [Datacenter-Proxy](https://proxynet.io/de/datacenter-proxy) eine feste Ausgangsadresse in einem Rechenzentrum nahe am Ziel, sodass die zusätzliche Zeit klein und gleichmäßig bleibt.

Für große Crawls enthält unser [Web-Crawler-Setup](/de/web-crawler) eine einstellbare Wartezeit zwischen den Anfragen; so bleibt Ihre Last auf dem Ziel niedrig genug, dass seine Seiten gar nicht erst langsamer werden.

## Wo Ihnen HTTP 499 begegnet

- Ein nginx-Zugriffsprotokoll mit 499-Zeilen, die sich bei einer Anfragedauer häufen.
- Ein Protokollexport von Cloudflare mit 499ern neben einem langsamen Ursprungsserver.
- Eine API, deren mobile Clients auf dem Weg zur Arbeit 499er erzeugen.
- Ein Crawler oder Datenjob, dessen Lese-Timeout kürzer ist als die Antwortzeit des Ziels.

## Häufige Fehler

- **499 als Serverfehler behandeln.** Wer 499er zusammen mit 5xx-Fehlern zählt, sucht nach Abstürzen, die es nicht gibt.
- **Jedes Timeout auf mehrere Minuten erhöhen.** Die 499er verschwinden, aber langsame Anfragen halten nun minutenlang Verbindungen und Worker fest, und der Nutzer wartet trotzdem.
- **`proxy_ignore_client_abort` überall einschalten.** Eine Welle ungeduldiger Clients wird zu einer Welle von Arbeit zum vollen Preis.
- **Einen POST nach einem Timeout blind wiederholen.** Der erste Versuch war womöglich erfolgreich, und die Wiederholung erzeugt eine doppelte Bestellung oder einen doppelten Eintrag.
- **Dasselbe knappe Timeout über einen Proxy beibehalten.** Der zusätzliche Abschnitt braucht Spielraum; messen Sie ihn zuerst.

## Entscheidungshilfe

| Situation | Was zu tun ist |
|---|---|
| 499er häufen sich bei einer Anfragedauer | Den Client oder Load Balancer mit diesem Timeout finden und abstimmen |
| 499er verstreut auf einer langsamen Seite | Diesen Endpoint beschleunigen oder zum Hintergrundjob machen |
| 499er von der IP Ihres Load Balancers | Sein Timeout über das von nginx heben, weitergeleitete IPs protokollieren |
| Ihr Skript erzeugt 499er auf einer Website | Längeres Lese-Timeout, nur GET wiederholen, weniger parallele Anfragen |
| Arbeit muss fertig werden, auch wenn der Client geht | Hintergrundjob oder `proxy_ignore_client_abort` auf diesem Pfad |
| Plötzlicher Anstieg von 499 bei Cloudflare | Mit allen Anfragen vergleichen, Zeit des Ursprungsservers und Cache prüfen |

## Häufige Fragen

### Ist HTTP 499 ein Client- oder ein Serverfehler?

Er wird als Ereignis auf Client-Seite verzeichnet: Der Client hat die Verbindung vor der Antwort geschlossen. Die Ursache kann trotzdem beim Server liegen, denn erst die langsame Antwort hat den Client zum Aufgeben gebracht.

### Kann ein Nutzer eine 499-Fehlerseite sehen?

Nein. An den Client wird nichts gesendet, ein Browser zeigt also nie „499“. Der Nutzer sieht eine Seite, die nicht mehr weiterlädt, oder die eigene Timeout-Meldung des Browsers.

### Was bedeutet 499 bei nginx?

Es ist der eigene Code von nginx für „Client Closed Request“: Der Client hat die Verbindung geschlossen, bevor nginx den Antwort-Header gesendet hat. nginx definiert ihn, weil der HTTP-Standard für diesen Fall keinen Code hat.

### Was bedeutet HTTP 499 bei Cloudflare?

Dasselbe: Der Client hat die Verbindung geschlossen, bevor Cloudflare die Anfrage abgeschlossen hatte. Der Code erscheint nur in Protokollen und Auswertungen, meist wegen Client-Timeouts, langsamer Ursprungsserver oder Cache-Fehltreffern.

### Bedeutet ein 499, dass der Server die Anfrage nicht weiter verarbeitet hat?

Nicht unbedingt. Standardmäßig schließt nginx seine Verbindung zur Anwendung, aber die Anwendung arbeitet womöglich weiter, bis sie die Antwort senden will; ein POST mit Timeout kann also trotzdem abgeschlossen worden sein.

### Wie beheben Sie ein 499-Timeout?

Ermitteln Sie anhand von Anfragedauer und Client-Adresse im Protokoll, wer die Verbindung geschlossen hat, beschleunigen Sie langsame Arbeit oder verlagern Sie sie in einen Hintergrundjob, und stellen Sie dann jedes Timeout länger ein als das der Schicht dahinter.

## Fazit

HTTP 499 ist der Protokolleintrag von nginx für einen Client, der die Verbindung geschlossen hat, bevor der Server antwortete; er ist kein offizieller Statuscode und erreicht den Client nie. Gehäufte Anfragedauern deuten auf ein Timeout irgendwo in der Kette, verstreute auf langsame Seiten und ungeduldige Nutzer. Beheben Sie den langsamen Endpoint, holen Sie lange Arbeit aus der Anfrage heraus und stimmen Sie die Timeouts vom Client nach innen ab. Ist Ihr eigenes Skript der Client, geben Sie ihm ein Lese-Timeout, das das Ziel und jeden Proxy-Abschnitt abdeckt, wiederholen Sie nur sichere Anfragen und vergleichen Sie unsere [Proxy-Typen](/de/proxy), wenn Sie einen gleichmäßigeren Ausgang brauchen.
