---
title: "HTTP-fout 499 oplossen en zien wie stopte met wachten"
description: "HTTP 499 is de status die nginx logt als de client de verbinding sluit vóór het antwoord. De client ziet hem nooit, en in onze test maakte de upstream elk request af."
canonical: "https://logbrew.co/nl/errors/http-499"
last_updated: "2026-11-21"
---

# HTTP-fout 499 oplossen en zien wie stopte met wachten

HTTP 499 is de status die nginx logt als de client de verbinding sluit vóór het antwoord. De client ziet hem nooit, en in onze test maakte de upstream elk request af.

Getest op 21 november 2026 met nginx 1.31.8, curl 8.7.1, Python 3.13.5 en logbrew CLI 0.1.96

Door [Furkan Erday](https://github.com/furkanerday). Furkan Erday is de oprichter van LogBrew. Hij bouwt LogBrew elke dag met Claude Code en Codex.

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

## Wie stopte met wachten, en wat nginx logde

| Wie stopte met wachten | Client kreeg antwoord | `499` gelogd |
| --- | --- | --- |
| Niemand, de upstream antwoordde in 0,2 s | `200` | `200` |
| De client, na 2 s | Nee | `499` |
| De client, na 0,3 s | Nee | `499` |
| nginx, na `proxy_read_timeout 3s` | `504` | `504` |
| De client, nginx bleef wachten | Nee | `200` |

5 requests via nginx 1.31.8, verstuurd met curl 8.7.1. Bij de laatste stond `proxy_ignore_client_abort on` aan.

## Zien wie stopte met wachten

### Zoek de 499-regels in de access log

nginx schrijft `499` naar de access log, en alleen daar. In het standaardformaat `combined` toont de regel het request en 0 verstuurde bytes, maar niet hoe lang iemand wachtte.

Uitvoer

```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"
```

### Log hoe lang elke kant wachtte

Zet `$request_time`, `$upstream_status` en `$upstream_response_time` in een `log_format` in het `http`-blok, naast je standaardlog. Voer daarna `nginx -s reload` uit.

```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;
```

### Lees request_time op elke 499-regel

`request_time` is hoe lang de client wachtte voordat hij ophing. Onze clients gaven op na 2 s en na 0,3 s, en nginx logde 2,006 en 0,301. `upstream_status` is `-`, omdat de upstream nog niet had geantwoord.

Uitvoer

```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
```

### Zoek 1 waarde die terugkomt

Veel 499-regels met bijna dezelfde `request_time` wijzen op een vaste time-out vóór nginx, zoals die van de client zelf. 3 clients met `--max-time 2` gaven 3 regels van 2,008 tot 2,011 s. Vergelijk die waarde met `upstream_response_time` op de 200-regels van hetzelfde pad. Duurt de upstream vaak langer, dan is hij te traag voor die client.

Uitvoer

```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
```

### Onderscheid 499 van 504

Stopt nginx als eerste met wachten, dan logt het `504` en krijgt de client een 504-pagina. `request_time` is dan je `proxy_read_timeout`, 3 s in onze test, en `upstream_status` is `504`, niet `-`. In de error log staat `upstream timed out`.

Uitvoer

```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"
```

## Oplossen

### Laat de upstream antwoorden voordat de client opgeeft

Delen de 499-regels 1 `request_time` en duren de 200-regels van dat pad langer, maak dat endpoint dan sneller of verhoog de time-out in de client. Een korte `request_time`, zoals onze 0,301, betekent dat de client het request zelf afbrak, bijvoorbeeld toen iemand de pagina verliet.

### Stop werk waar niemand op wacht

Onze upstream logde 200 voor beide requests die nginx als 499 logde. Hij maakte ze 3 s en 0,7 s nadat de client weg was af. nginx sloot zijn verbinding met de upstream, maar de upstream merkte het niet. Controleer in lange handlers of de verbinding dicht is, of verplaats traag werk naar een achtergrondtaak.

Uitvoer

```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
```

### Laat proxy_ignore_client_abort uit

Met `proxy_ignore_client_abort on` wachtte nginx op de upstream en logde het `200` met een `request_time` van 5,006, terwijl curl na 2 s had opgehangen. De 499 was uit de log verdwenen. `off` is de standaard.

```bash
proxy_ignore_client_abort off;
```

Uitvoer

```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
```

### Stuur de 499-regels naar LogBrew

LogBrew heeft geen nginx-integratie, maar neemt OTLP-logs aan. Deze opdracht stuurt elke 499- en 504-regel als 1 log. Zet `LOGBREW_INGEST_KEY` op een `server`-sleutel van je project. Onze lokale LogBrew-API antwoordde `{}`, dus nam hij elke regel aan.

```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 @-
```

Uitvoer

```text
{}
```

### Zoek ze met de LogBrew-CLI

Elke regel is 1 log met het niveau `warning`, en het bericht is de hele regel. Zet spaties rond 499 in de zoekopdracht, zodat een 499 in een pad of een tijd niet meetelt.

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

Uitvoer

```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]
```

## Wat we zagen toen we het testten

We draaiden nginx 1.31.8 op macOS 27.2 op `127.0.0.1:28499`, vóór een upstream in Python 3.13 die het aantal seconden uit `?delay=` wacht en dan 200 antwoordt. curl 8.7.1 stuurde 5 requests, 3 daarvan met `--max-time`.

In beide 499-regels zat `request_time` binnen 6 ms van de curl-time-out, en `upstream_status` was `-`. In de 504-regel kwam hij overeen met `proxy_read_timeout`, en `upstream_status` was `504`.

|  | `$status` | `$request_time` | `$upstream_status` |
| --- | --- | --- | --- |
| Niemand gaf op | `200` | 0,206 sec | `200` |
| De client gaf op na 2 s | `499` | 2,006 sec | `-` |
| De client gaf op na 0,3 s | `499` | 0,301 sec | `-` |
| nginx gaf op na 3 s | `504` | 3,001 sec | `504` |
| De client gaf op, nginx bleef wachten | `200` | 5,006 sec | `200` |

## Waarom alleen nginx 499 ziet

499 is geen HTTP-statuscode. RFC 9110 definieert de 4xx-codes, en 499 hoort daar niet bij. nginx definieert hem in `src/http/ngx_http_request.h` als `NGX_HTTP_CLIENT_CLOSED_REQUEST`, voor een client die de verbinding sloot voordat nginx de response-header stuurde.

De client krijgt nooit een 499, want zijn verbinding is al dicht. nginx sluit ook de verbinding met de upstream en schrijft `499` naar de access log.

Op het standaardniveau van de error log, `error`, schrijft nginx verder niets over een 499. Op het niveau `info` schrijft het `client prematurely closed connection`. Een 504 verschijnt op het niveau `error`.

1. De client sluit de verbinding
2. nginx sluit de verbinding met de upstream
3. nginx schrijft 499 naar de access log

## Wat LogBrew vastlegt

LogBrew bewaarde elke regel die we stuurden als 1 log van de dienst `nginx`, met het niveau `warning`. Het houdt de hele regel als bericht en splitst hem niet in velden, dus zoek in de tekst.

Het dashboard, de CLI en de MCP-server lezen deze logs zoals elke andere LogBrew-log.

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

## Veelgestelde vragen

### Wat betekent HTTP-statuscode 499?

De client sloot de verbinding voordat nginx het antwoord stuurde, en nginx logde 499. De status hoort niet bij HTTP, en de client krijgt hem nooit.

### Komt een 499-fout door de client of door de server?

De client sluit de verbinding, maar vaak is een trage upstream de reden. Vergelijk `request_time` op de 499-regels met `upstream_response_time` op de 200-regels van hetzelfde pad.

### Wat is het verschil tussen 499 en 504?

499 betekent dat de client als eerste stopte met wachten. 504 betekent dat nginx als eerste stopte met wachten, na `proxy_read_timeout`, en de client krijgt de 504.

### Hoe los ik 499-fouten in nginx op?

Zoek de time-out van de client in `request_time`, en laat de upstream eerder antwoorden of verhoog die time-out. `proxy_ignore_client_abort on` verbergt de 499 alleen in de log.

### Weet de upstream dat de client weg is?

In onze test niet. Onze Python-upstream logde 200 voor beide requests die nginx als 499 logde, en maakte elk af toen de client al weg was.

## Doorzoek elke 499-regel op 1 plek

Stuur je nginx-logregels als OTLP-logs naar LogBrew en doorzoek ze vanuit het dashboard, de CLI of je AI-agent. Begin met het ruime gratis abonnement, zonder creditcard.

[Gratis beginnen](https://logbrew.co/nl)

## Bronnen

- [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)

## Meer fouten oplossen

- [De Script error oplossen die zijn melding, bestand en regel verbergt](https://logbrew.co/nl/errors/script-error)
- [De fout Failed to fetch oplossen en de 3 oorzaken uit elkaar houden](https://logbrew.co/nl/errors/failed-to-fetch)
- [java.lang.NullPointerException in Kotlin en Android oplossen via de melding](https://logbrew.co/nl/errors/nullpointerexception)
- [Los Minified React error #418 en #185 op met de volledige melding en je eigen regel](https://logbrew.co/nl/errors/minified-react-error)
- [Cannot use import statement outside a module oplossen in de browser en in Node.js](https://logbrew.co/nl/errors/cannot-use-import-statement-outside-a-module)
- [AxiosError Network Error oplossen en zien welke van de 3 oorzaken je hebt](https://logbrew.co/nl/errors/axios-network-error)
- [Fouten die we reproduceerden, en hoe je elke oplost](https://logbrew.co/nl/errors)
