---
title: "Corrija o erro HTTP 499 e descubra quem parou de esperar"
description: "HTTP 499 é o status que o nginx registra quando o cliente fecha a conexão antes da resposta. O cliente nunca o vê, e no nosso teste o upstream terminou todas as requisições."
canonical: "https://logbrew.co/pt-BR/errors/http-499"
last_updated: "2026-11-21"
---

# Corrija o erro HTTP 499 e descubra quem parou de esperar

HTTP 499 é o status que o nginx registra quando o cliente fecha a conexão antes da resposta. O cliente nunca o vê, e no nosso teste o upstream terminou todas as requisições.

Testado em 21 de novembro de 2026 com nginx 1.31.8, curl 8.7.1, Python 3.13.5 e logbrew CLI 0.1.96

Por [Furkan Erday](https://github.com/furkanerday). Furkan Erday é o fundador do LogBrew. Ele desenvolve o LogBrew com Claude Code e Codex todos os dias.

Canonical: https://logbrew.co/pt-BR/errors/http-499

## Quem parou de esperar, e o que o nginx registrou

| Quem parou de esperar | O cliente recebeu resposta | Registrou `499` |
| --- | --- | --- |
| Ninguém, o upstream respondeu em 0,2 s | `200` | `200` |
| O cliente, depois de 2 s | Não | `499` |
| O cliente, depois de 0,3 s | Não | `499` |
| O nginx, depois de `proxy_read_timeout 3s` | `504` | `504` |
| O cliente, o nginx continuou esperando | Não | `200` |

5 requisições pelo nginx 1.31.8, enviadas com curl 8.7.1. A última usou `proxy_ignore_client_abort on`.

## Descubra quem parou de esperar

### Ache as linhas 499 no access log

O nginx escreve `499` no access log, e só nele. No formato padrão `combined`, a linha mostra a requisição e 0 bytes enviados, mas não quanto tempo cada lado esperou.

Saída

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

### Registre quanto tempo cada lado esperou

Adicione `$request_time`, `$upstream_status` e `$upstream_response_time` a um `log_format` no bloco `http`, ao lado do seu log padrão. Depois rode `nginx -s reload`.

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

### Leia o request_time em cada linha 499

`request_time` é quanto tempo o cliente esperou antes de desistir. Nossos clientes desistiram depois de 2 s e de 0,3 s, e o nginx registrou 2,006 e 0,301. O `upstream_status` é `-` porque o upstream ainda não tinha respondido.

Saída

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

### Procure 1 valor que se repete

Muitas linhas 499 com quase o mesmo `request_time` indicam um timeout fixo antes do nginx, como o do próprio cliente. 3 clientes com `--max-time 2` geraram 3 linhas de 2,008 a 2,011 s. Compare esse valor com o `upstream_response_time` das linhas 200 do mesmo caminho. Se o upstream costuma levar mais tempo, ele está lento demais para esse cliente.

Saída

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

### Diferencie 499 de 504

Quando o nginx para de esperar primeiro, ele registra `504`, e o cliente recebe uma página 504. Aí o `request_time` é o seu `proxy_read_timeout`, 3 s no nosso teste, e o `upstream_status` é `504`, não `-`. O error log diz `upstream timed out`.

Saída

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

## Corrija

### Faça o upstream responder antes de o cliente desistir

Se as linhas 499 têm o mesmo `request_time` e as linhas 200 desse caminho demoram mais, acelere esse endpoint ou aumente o timeout no cliente. Um `request_time` curto, como o nosso 0,301, significa que o próprio cliente cancelou a requisição, por exemplo quando o usuário sai da página.

### Pare o trabalho que ninguém espera

Nosso upstream registrou 200 nas duas requisições que o nginx registrou como 499. Ele as terminou 3 s e 0,7 s depois que o cliente saiu. O nginx fechou a conexão com o upstream, mas o upstream não percebeu. Verifique se a conexão foi fechada nos handlers longos, ou mova o trabalho lento para um job em segundo plano.

Saída

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

### Mantenha proxy_ignore_client_abort desligado

Com `proxy_ignore_client_abort on`, o nginx esperou o upstream e registrou `200` com um `request_time` de 5,006, embora o curl tivesse desistido depois de 2 s. O 499 sumiu do log. `off` é o padrão.

```bash
proxy_ignore_client_abort off;
```

Saída

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

### Envie as linhas 499 ao LogBrew

O LogBrew não tem integração com o nginx, mas aceita logs OTLP. Este comando envia cada linha 499 e 504 como 1 log. Defina `LOGBREW_INGEST_KEY` com uma chave `server` do seu projeto. Nossa API local do LogBrew respondeu `{}`, então aceitou todas as linhas.

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

Saída

```text
{}
```

### Busque as linhas com a CLI do LogBrew

Cada linha é 1 log com o nível `warning`, e a mensagem é a linha inteira. Coloque espaços em volta do 499 na busca, para não pegar um 499 dentro de um caminho ou de um horário.

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

Saída

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

## O que vimos no teste

Rodamos o nginx 1.31.8 no macOS 27.2 em `127.0.0.1:28499`, na frente de um upstream em Python 3.13 que espera os segundos de `?delay=` e depois responde 200. O curl 8.7.1 enviou 5 requisições, 3 delas com `--max-time`.

Nas duas linhas 499, o `request_time` ficou a menos de 6 ms do timeout do curl, e o `upstream_status` foi `-`. Na linha 504, ele bateu com o `proxy_read_timeout`, e o `upstream_status` foi `504`.

|  | `$status` | `$request_time` | `$upstream_status` |
| --- | --- | --- | --- |
| Ninguém desistiu | `200` | 0,206 s | `200` |
| O cliente desistiu depois de 2 s | `499` | 2,006 s | `-` |
| O cliente desistiu depois de 0,3 s | `499` | 0,301 s | `-` |
| O nginx desistiu depois de 3 s | `504` | 3,001 s | `504` |
| O cliente desistiu, o nginx continuou esperando | `200` | 5,006 s | `200` |

## Por que só o nginx vê o 499

499 não é um código de status HTTP. A RFC 9110 define os códigos 4xx, e o 499 não é um deles. O nginx o define em `src/http/ngx_http_request.h` como `NGX_HTTP_CLIENT_CLOSED_REQUEST`, para um cliente que fechou a conexão antes de o nginx enviar o cabeçalho da resposta.

O cliente nunca recebe um 499, porque a conexão dele já está fechada. O nginx também fecha a conexão com o upstream e escreve `499` no access log.

No nível padrão do error log, `error`, o nginx não escreve mais nada sobre um 499. No nível `info`, ele escreve `client prematurely closed connection`. Um 504 aparece no nível `error`.

1. O cliente fecha a conexão
2. O nginx fecha a conexão com o upstream
3. O nginx escreve 499 no access log

## O que o LogBrew registra

O LogBrew guardou cada linha que enviamos como 1 log do serviço `nginx`, com o nível `warning`. Ele mantém a linha inteira como mensagem e não a divide em campos, então busque no texto.

O painel, a CLI e o servidor MCP leem esses logs como qualquer outro log do LogBrew.

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

## Perguntas frequentes

### O que significa o código de status HTTP 499?

O cliente fechou a conexão antes de o nginx enviar a resposta, e o nginx registrou 499. Esse status não faz parte do HTTP, e o cliente nunca o recebe.

### O erro 499 é causado pelo cliente ou pelo servidor?

Quem fecha a conexão é o cliente, mas muitas vezes o motivo é um upstream lento. Compare o `request_time` das linhas 499 com o `upstream_response_time` das linhas 200 do mesmo caminho.

### Qual é a diferença entre 499 e 504?

499 significa que o cliente parou de esperar primeiro. 504 significa que o nginx parou de esperar primeiro, depois do `proxy_read_timeout`, e o cliente recebe o 504.

### Como corrijo erros 499 no nginx?

Ache o timeout do cliente no `request_time` e faça o upstream responder antes dele, ou aumente esse timeout. `proxy_ignore_client_abort on` só esconde o 499 no log.

### O upstream sabe que o cliente foi embora?

No nosso teste, não. Nosso upstream em Python registrou 200 nas duas requisições que o nginx registrou como 499, e terminou cada uma depois que o cliente já tinha saído.

## Busque cada linha 499 em 1 só lugar

Envie as linhas de log do nginx ao LogBrew como logs OTLP e busque no painel, na CLI ou no seu agente de IA. Comece no plano gratuito generoso, sem cartão.

[Comece grátis](https://logbrew.co/pt-BR)

## Fontes

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

## Mais correções de erros

- [Corrija o erro de script que esconde a mensagem, o arquivo e a linha](https://logbrew.co/pt-BR/errors/script-error)
- [Corrija o erro Failed to fetch e distinga as 3 causas](https://logbrew.co/pt-BR/errors/failed-to-fetch)
- [Corrija java.lang.NullPointerException no Kotlin e no Android a partir da mensagem](https://logbrew.co/pt-BR/errors/nullpointerexception)
- [Corrija Minified React error #418 e #185 com a mensagem completa e a sua linha de código](https://logbrew.co/pt-BR/errors/minified-react-error)
- [Corrija Cannot use import statement outside a module no navegador e no Node.js](https://logbrew.co/pt-BR/errors/cannot-use-import-statement-outside-a-module)
- [Corrija AxiosError Network Error e descubra qual das 3 causas você tem](https://logbrew.co/pt-BR/errors/axios-network-error)
- [Erros que reproduzimos, e como corrigir cada um](https://logbrew.co/pt-BR/errors)
