---
title: "HTTP-Fehler 499 beheben und herausfinden, wer nicht mehr gewartet hat"
description: "HTTP 499 protokolliert nginx, wenn der Client die Verbindung vor der Antwort schließt. Der Client sieht ihn nie, und in unserem Test hat der Upstream jede Anfrage beendet."
canonical: "https://logbrew.co/de/errors/http-499"
last_updated: "2026-11-21"
---

# HTTP-Fehler 499 beheben und herausfinden, wer nicht mehr gewartet hat

HTTP 499 protokolliert nginx, wenn der Client die Verbindung vor der Antwort schließt. Der Client sieht ihn nie, und in unserem Test hat der Upstream jede Anfrage beendet.

Getestet am 21. November 2026 mit nginx 1.31.8, curl 8.7.1, Python 3.13.5 und logbrew CLI 0.1.96

Von [Furkan Erday](https://github.com/furkanerday). Furkan Erday hat LogBrew gegründet. Er entwickelt LogBrew jeden Tag mit Claude Code und Codex.

Canonical: https://logbrew.co/de/errors/http-499

## Wer nicht mehr gewartet hat und was nginx protokolliert

| Wer nicht mehr gewartet hat | Client bekam eine Antwort | `499` protokolliert |
| --- | --- | --- |
| Niemand, der Upstream antwortete nach 0,2 s | `200` | `200` |
| Der Client, nach 2 s | Nein | `499` |
| Der Client, nach 0,3 s | Nein | `499` |
| nginx, nach `proxy_read_timeout 3s` | `504` | `504` |
| Der Client, nginx wartete weiter | Nein | `200` |

5 Anfragen durch nginx 1.31.8, gesendet mit curl 8.7.1. Die letzte lief mit `proxy_ignore_client_abort on`.

## Herausfinden, wer nicht mehr gewartet hat

### Die 499-Zeilen im Access-Log finden

nginx schreibt `499` ins Access-Log und nur dorthin. Im Standardformat `combined` zeigt die Zeile die Anfrage und 0 gesendete Bytes, aber nicht, wie lange jemand gewartet hat.

Ausgabe

```text
127.0.0.1 - - [21/Nov/2026:17:09:07 +0300] "GET /api/report?delay=5 HTTP/1.1" 499 0 "-" "curl/8.7.1"
127.0.0.1 - - [21/Nov/2026:17:09:08 +0300] "GET /api/report?delay=1 HTTP/1.1" 499 0 "-" "curl/8.7.1"
```

### Protokollieren, wie lange jede Seite gewartet hat

Füge `$request_time`, `$upstream_status` und `$upstream_response_time` in ein `log_format` im Block `http` ein, neben deinem Standard-Log. Führe dann `nginx -s reload` aus.

```bash
log_format timing '$remote_addr "$request" $status $body_bytes_sent '
                  'request_time=$request_time '
                  'upstream_status=$upstream_status '
                  'upstream_response_time=$upstream_response_time';
access_log /var/log/nginx/timing.log timing;
```

### request_time in jeder 499-Zeile lesen

`request_time` ist die Zeit, die der Client gewartet hat, bevor er aufgelegt hat. Unsere Clients gaben nach 2 s und nach 0,3 s auf, und nginx protokollierte 2,006 s und 0,301 s. `upstream_status` ist `-`, weil der Upstream noch nicht geantwortet hatte.

Ausgabe

```text
127.0.0.1 "GET /api/report?delay=5 HTTP/1.1" 499 0 request_time=2.006 upstream_status=- upstream_response_time=2.006
127.0.0.1 "GET /api/report?delay=1 HTTP/1.1" 499 0 request_time=0.301 upstream_status=- upstream_response_time=0.301
```

### Nach einem Wert suchen, der sich wiederholt

Viele 499-Zeilen mit fast gleicher `request_time` deuten auf ein festes Timeout vor nginx hin, etwa das des Clients selbst. 3 Clients mit `--max-time 2` ergaben 3 Zeilen mit 2,008 bis 2,011 s. Vergleiche diesen Wert mit `upstream_response_time` in den 200-Zeilen desselben Pfads. Braucht der Upstream oft länger, ist er für diesen Client zu langsam.

Ausgabe

```text
127.0.0.1 "GET /api/report?delay=4 HTTP/1.1" 499 0 request_time=2.011 upstream_status=- upstream_response_time=2.011
127.0.0.1 "GET /api/report?delay=4 HTTP/1.1" 499 0 request_time=2.011 upstream_status=- upstream_response_time=2.012
127.0.0.1 "GET /api/report?delay=4 HTTP/1.1" 499 0 request_time=2.008 upstream_status=- upstream_response_time=2.007
```

### 499 von 504 unterscheiden

Hört nginx zuerst auf zu warten, protokolliert es `504`, und der Client bekommt eine 504-Seite. `request_time` ist dann dein `proxy_read_timeout`, in unserem Test 3 s, und `upstream_status` ist `504`, nicht `-`. Im Error-Log steht `upstream timed out`.

Ausgabe

```text
127.0.0.1 "GET /short/report?delay=5 HTTP/1.1" 504 167 request_time=3.001 upstream_status=504 upstream_response_time=3.001
2026/11/21 17:09:11 [error] 61151#0: *35 upstream timed out (60: Operation timed out) while reading response header from upstream, client: 127.0.0.1, server: , request: "GET /short/report?delay=5 HTTP/1.1", upstream: "http://127.0.0.1:28500/api/report?delay=5", host: "127.0.0.1:28499"
```

## Beheben

### Den Upstream antworten lassen, bevor der Client aufgibt

Haben die 499-Zeilen dieselbe `request_time` und brauchen die 200-Zeilen dieses Pfads länger, mach diesen Endpoint schneller oder erhöhe das Timeout im Client. Eine kurze `request_time` wie unsere 0,301 s heißt, dass der Client die Anfrage selbst abgebrochen hat, etwa weil jemand die Seite verlassen hat.

### Arbeit stoppen, auf die niemand wartet

Unser Upstream protokollierte 200 für beide Anfragen, die nginx als 499 protokollierte. Er beendete sie 3 s und 0,7 s, nachdem der Client weg war. nginx schloss seine Upstream-Verbindung, aber der Upstream merkte es nicht. Prüfe in langen Handlern auf eine geschlossene Verbindung, oder verschiebe langsame Arbeit in einen Hintergrundjob.

Ausgabe

```text
14:09:05.796 upstream got /api/report?delay=5
14:09:07.822 upstream got /api/report?delay=1
14:09:08.827 upstream answered 200 after 1.0s
14:09:10.802 upstream answered 200 after 5.0s
```

### proxy_ignore_client_abort ausgeschaltet lassen

Mit `proxy_ignore_client_abort on` wartete nginx auf den Upstream und protokollierte `200` mit einer `request_time` von 5,006 s, obwohl curl nach 2 s aufgelegt hatte. Die 499 war aus dem Log verschwunden. `off` ist der Standard.

```bash
proxy_ignore_client_abort off;
```

Ausgabe

```text
127.0.0.1 "GET /keep/report?delay=5 HTTP/1.1" 200 12 request_time=5.006 upstream_status=200 upstream_response_time=5.006
```

### Die 499-Zeilen an LogBrew senden

LogBrew hat keine nginx-Integration, nimmt aber OTLP-Logs an. Dieser Befehl sendet jede 499- und 504-Zeile als 1 Log. Setze `LOGBREW_INGEST_KEY` auf einen `server`-Schlüssel deines Projekts. Unsere lokale LogBrew-API antwortete `{}`, hat also jede Zeile angenommen.

```bash
grep -E '" (499|504) ' /var/log/nginx/timing.log |
  jq -Rn '{resourceLogs: [{resource: {attributes: [{key: "service.name", value: {stringValue: "nginx"}}]}, scopeLogs: [{logRecords: [inputs | {severityText: "WARN", body: {stringValue: .}}]}]}]}' |
  curl -sS https://api.logbrew.co/v1/logs -H "x-logbrew-key: $LOGBREW_INGEST_KEY" \
    -H 'Content-Type: application/json' --data-binary @-
```

Ausgabe

```text
{}
```

### Mit der LogBrew-CLI danach suchen

Jede Zeile ist 1 Log mit dem Level `warning`, und ihre Nachricht ist die ganze Zeile. Setze Leerzeichen um 499 in der Suche, damit keine 499 in einem Pfad oder einer Zeit passt.

```bash
logbrew read logs --project "<project_id>" --service nginx --search ' 499 ' --since 1h
```

Ausgabe

```text
Logs (2)
- warning 127.0.0.1 "GET /api/report?delay=1 HTTP/1.1" 499 0 request_time=0.301 upstream_status=- upstream_response_time=0.301 service=nginx trace=3ded5398edda96df764625b26d6274f2 [unversioned / production]
- warning 127.0.0.1 "GET /api/report?delay=5 HTTP/1.1" 499 0 request_time=2.006 upstream_status=- upstream_response_time=2.006 service=nginx trace=4ad4df7e9d1f37c7dc182a77a1e83012 [unversioned / production]
```

## Was wir beim Testen gesehen haben

Wir haben nginx 1.31.8 auf macOS 27.2 unter `127.0.0.1:28499` betrieben, vor einem Upstream in Python 3.13, der die Sekunden aus `?delay=` wartet und dann mit 200 antwortet. curl 8.7.1 sendete 5 Anfragen, 3 davon mit `--max-time`.

In beiden 499-Zeilen lag `request_time` höchstens 6 ms neben dem curl-Timeout, und `upstream_status` war `-`. In der 504-Zeile entsprach sie `proxy_read_timeout`, und `upstream_status` war `504`.

|  | `$status` | `$request_time` | `$upstream_status` |
| --- | --- | --- | --- |
| Niemand hat aufgegeben | `200` | 0,206 Sek. | `200` |
| Der Client gab nach 2 s auf | `499` | 2,006 Sek. | `-` |
| Der Client gab nach 0,3 s auf | `499` | 0,301 Sek. | `-` |
| nginx gab nach 3 s auf | `504` | 3,001 Sek. | `504` |
| Der Client gab auf, nginx wartete weiter | `200` | 5,006 Sek. | `200` |

## Warum nur nginx die 499 sieht

499 ist kein HTTP-Statuscode. RFC 9110 definiert die 4xx-Codes, und 499 gehört nicht dazu. nginx definiert ihn in `src/http/ngx_http_request.h` als `NGX_HTTP_CLIENT_CLOSED_REQUEST`, für einen Client, der die Verbindung geschlossen hat, bevor nginx den Antwort-Header gesendet hat.

Der Client bekommt nie eine 499, weil seine Verbindung schon geschlossen ist. nginx schließt auch die Upstream-Verbindung und schreibt `499` ins Access-Log.

Auf dem Standard-Level des Error-Logs, `error`, schreibt nginx sonst nichts über eine 499. Auf dem Level `info` schreibt es `client prematurely closed connection`. Eine 504 erscheint auf dem Level `error`.

1. Der Client schließt die Verbindung
2. nginx schließt die Upstream-Verbindung
3. nginx schreibt 499 ins Access-Log

## Was LogBrew aufzeichnet

LogBrew speicherte jede gesendete Zeile als 1 Log des Dienstes `nginx` mit dem Level `warning`. Es behält die ganze Zeile als Nachricht und zerlegt sie nicht in Felder, also durchsuche den Text.

Das Dashboard, die CLI und der MCP-Server lesen diese Logs wie jedes andere LogBrew-Log.

- `nginx`
  - `level`: `warning`
  - Meldung: `… 499 0 request_time=0.301 …`
  - `trace`: `3ded5398edda96df764625b26d6274f2`

## Häufige Fragen

### Was bedeutet der HTTP-Statuscode 499?

Der Client hat die Verbindung geschlossen, bevor nginx die Antwort gesendet hat, und nginx hat 499 protokolliert. Der Status gehört nicht zu HTTP, und der Client bekommt ihn nie.

### Liegt ein 499-Fehler am Client oder am Server?

Der Client schließt die Verbindung, aber oft ist ein langsamer Upstream der Grund. Vergleiche `request_time` in den 499-Zeilen mit `upstream_response_time` in den 200-Zeilen desselben Pfads.

### Was ist der Unterschied zwischen 499 und 504?

499 heißt, der Client hat zuerst aufgehört zu warten. 504 heißt, nginx hat zuerst aufgehört zu warten, nach `proxy_read_timeout`, und der Client bekommt die 504.

### Wie behebe ich 499-Fehler in nginx?

Finde das Timeout des Clients in `request_time`, und lass den Upstream vorher antworten oder erhöhe dieses Timeout. `proxy_ignore_client_abort on` versteckt die 499 nur im Log.

### Weiß der Upstream, dass der Client weg ist?

In unserem Test nicht. Unser Python-Upstream protokollierte 200 für beide Anfragen, die nginx als 499 protokollierte, und beendete jede, als der Client schon weg war.

## Jede 499-Zeile an 1 Ort durchsuchen

Sende deine nginx-Logzeilen als OTLP-Logs an LogBrew und durchsuche sie im Dashboard, in der CLI oder mit deinem KI-Agenten. Starte mit dem großzügigen kostenlosen Plan, ohne Kreditkarte.

[Kostenlos starten](https://logbrew.co/de)

## Quellen

- [RFC 9110, HTTP Semantics, 15.5 Client Error 4xx](https://www.rfc-editor.org/rfc/rfc9110#section-15.5)
- [MDN, 504 Gateway Timeout](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status/504)
- [LogBrew docs, Send OpenTelemetry data to LogBrew with OTLP](https://docs.logbrew.co/guides/opentelemetry)
- [LogBrewCo/docs, guides/opentelemetry.mdx](https://github.com/LogBrewCo/docs/blob/main/guides/opentelemetry.mdx)

## Weitere Fehler beheben

- [Den Script error beheben, der Meldung, Datei und Zeile verbirgt](https://logbrew.co/de/errors/script-error)
- [Den Fehler Failed to fetch beheben und seine 3 Ursachen unterscheiden](https://logbrew.co/de/errors/failed-to-fetch)
- [java.lang.NullPointerException in Kotlin und Android aus der Meldung beheben](https://logbrew.co/de/errors/nullpointerexception)
- [Minified React error #418 und #185 beheben, mit der vollen Meldung und deiner Quellzeile](https://logbrew.co/de/errors/minified-react-error)
- [Cannot use import statement outside a module im Browser und in Node.js beheben](https://logbrew.co/de/errors/cannot-use-import-statement-outside-a-module)
- [AxiosError Network Error beheben und herausfinden, welche der 3 Ursachen du hast](https://logbrew.co/de/errors/axios-network-error)
- [Fehler, die wir reproduziert haben, und wie du jeden behebst](https://logbrew.co/de/errors)
