---
title: "Soluciona el error HTTP 499 y averigua quién dejó de esperar"
description: "HTTP 499 es el estado que nginx registra cuando el cliente cierra la conexión antes de la respuesta. El cliente nunca lo ve, y en nuestra prueba el upstream terminó cada solicitud."
canonical: "https://logbrew.co/es/errors/http-499"
last_updated: "2026-11-21"
---

# Soluciona el error HTTP 499 y averigua quién dejó de esperar

HTTP 499 es el estado que nginx registra cuando el cliente cierra la conexión antes de la respuesta. El cliente nunca lo ve, y en nuestra prueba el upstream terminó cada solicitud.

Probado el 21 de noviembre de 2026 con nginx 1.31.8, curl 8.7.1, Python 3.13.5 y logbrew CLI 0.1.96

Por [Furkan Erday](https://github.com/furkanerday). Furkan Erday es el fundador de LogBrew. Desarrolla LogBrew con Claude Code y Codex todos los días.

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

## Quién dejó de esperar y qué registró nginx

| Quién dejó de esperar | El cliente recibió respuesta | Se registró `499` |
| --- | --- | --- |
| Nadie, el upstream respondió en 0,2 s | `200` | `200` |
| El cliente, tras 2 s | No | `499` |
| El cliente, tras 0,3 s | No | `499` |
| nginx, tras `proxy_read_timeout 3s` | `504` | `504` |
| El cliente, nginx siguió esperando | No | `200` |

5 solicitudes a través de nginx 1.31.8, enviadas con curl 8.7.1. La última usó `proxy_ignore_client_abort on`.

## Averigua quién dejó de esperar

### Busca las líneas 499 en el access log

nginx escribe `499` en el access log, y solo ahí. Con el formato predeterminado `combined`, la línea muestra la solicitud y 0 bytes enviados, pero no cuánto esperó cada lado.

Salida

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

### Registra cuánto esperó cada lado

Añade `$request_time`, `$upstream_status` y `$upstream_response_time` a un `log_format` en el bloque `http`, junto a tu log predeterminado. Luego ejecuta `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;
```

### Lee request_time en cada línea 499

`request_time` es cuánto esperó el cliente antes de colgar. Nuestros clientes se rindieron a los 2 s y a los 0,3 s, y nginx registró 2,006 y 0,301. `upstream_status` es `-` porque el upstream aún no había respondido.

Salida

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

### Busca un valor que se repita

Muchas líneas 499 con casi el mismo `request_time` apuntan a un timeout fijo delante de nginx, como el del propio cliente. 3 clientes con `--max-time 2` dieron 3 líneas de 2,008 a 2,011 s. Compara ese valor con `upstream_response_time` en las líneas 200 de la misma ruta. Si el upstream suele tardar más, es demasiado lento para ese cliente.

Salida

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

### Distingue 499 de 504

Cuando nginx deja de esperar primero, registra `504` y el cliente recibe una página 504. Entonces `request_time` es tu `proxy_read_timeout`, 3 s en nuestra prueba, y `upstream_status` es `504`, no `-`. El error log dice `upstream timed out`.

Salida

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

## Soluciónalo

### Haz que el upstream responda antes de que el cliente se rinda

Si las líneas 499 comparten un `request_time` y las líneas 200 de esa ruta tardan más, acelera ese endpoint o sube el timeout del cliente. Un `request_time` corto, como nuestro 0,301, significa que el cliente canceló la solicitud por su cuenta, por ejemplo cuando el usuario sale de la página.

### Detén el trabajo que nadie espera

Nuestro upstream registró 200 en las dos solicitudes que nginx registró como 499. Las terminó 3 s y 0,7 s después de que el cliente se fuera. nginx cerró su conexión con el upstream, pero el upstream no se enteró. Comprueba si la conexión sigue abierta en los handlers largos, o pasa el trabajo lento a un job en segundo plano.

Salida

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

### Deja proxy_ignore_client_abort desactivado

Con `proxy_ignore_client_abort on`, nginx esperó al upstream y registró `200` con un `request_time` de 5,006, aunque curl había colgado a los 2 s. El 499 desapareció del log. `off` es el valor predeterminado.

```bash
proxy_ignore_client_abort off;
```

Salida

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

### Envía las líneas 499 a LogBrew

LogBrew no tiene integración con nginx, pero acepta logs OTLP. Este comando envía cada línea 499 y 504 como 1 log. Define `LOGBREW_INGEST_KEY` con una clave `server` de tu proyecto. Nuestra API local de LogBrew respondió `{}`, así que aceptó cada línea.

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

Salida

```text
{}
```

### Búscalas con la CLI de LogBrew

Cada línea es 1 log con el nivel `warning`, y su mensaje es la línea entera. Pon espacios alrededor de 499 en la búsqueda, para que no coincida un 499 dentro de una ruta o de una hora.

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

Salida

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

## Lo que vimos al probarlo

Ejecutamos nginx 1.31.8 en macOS 27.2 en `127.0.0.1:28499`, delante de un upstream en Python 3.13 que espera los segundos de `?delay=` y luego responde 200. curl 8.7.1 envió 5 solicitudes, 3 de ellas con `--max-time`.

En las dos líneas 499, `request_time` coincidió con el timeout de curl con menos de 6 ms de diferencia, y `upstream_status` fue `-`. En la línea 504 coincidió con `proxy_read_timeout`, y `upstream_status` fue `504`.

|  | `$status` | `$request_time` | `$upstream_status` |
| --- | --- | --- | --- |
| Nadie se rindió | `200` | 0,206 s | `200` |
| El cliente se rindió a los 2 s | `499` | 2,006 s | `-` |
| El cliente se rindió a los 0,3 s | `499` | 0,301 s | `-` |
| nginx se rindió a los 3 s | `504` | 3,001 s | `504` |
| El cliente se rindió, nginx siguió esperando | `200` | 5,006 s | `200` |

## Por qué solo nginx ve el 499

499 no es un código de estado HTTP. RFC 9110 define los códigos 4xx, y 499 no es uno de ellos. nginx lo define en `src/http/ngx_http_request.h` como `NGX_HTTP_CLIENT_CLOSED_REQUEST`, para un cliente que cerró la conexión antes de que nginx enviara la cabecera de la respuesta.

El cliente nunca recibe un 499, porque su conexión ya está cerrada. nginx también cierra la conexión con el upstream y escribe `499` en el access log.

Con el nivel predeterminado del error log, `error`, nginx no escribe nada más sobre un 499. Con el nivel `info` escribe `client prematurely closed connection`. Un 504 aparece con el nivel `error`.

1. El cliente cierra la conexión
2. nginx cierra la conexión con el upstream
3. nginx escribe 499 en el access log

## Lo que registra LogBrew

LogBrew guardó cada línea que enviamos como 1 log del servicio `nginx`, con el nivel `warning`. Conserva la línea entera como mensaje y no la divide en campos, así que busca en el texto.

El panel, la CLI y el servidor MCP leen estos logs como cualquier otro log de LogBrew.

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

## Preguntas frecuentes

### ¿Qué significa el código de estado HTTP 499?

El cliente cerró la conexión antes de que nginx enviara la respuesta, y nginx registró 499. Ese estado no forma parte de HTTP, y el cliente nunca lo recibe.

### ¿Un error 499 lo causa el cliente o el servidor?

El cliente cierra la conexión, pero muchas veces la causa es un upstream lento. Compara `request_time` en las líneas 499 con `upstream_response_time` en las líneas 200 de la misma ruta.

### ¿Qué diferencia hay entre 499 y 504?

499 significa que el cliente dejó de esperar primero. 504 significa que nginx dejó de esperar primero, tras `proxy_read_timeout`, y el cliente recibe el 504.

### ¿Cómo soluciono los errores 499 en nginx?

Busca el timeout del cliente en `request_time` y haz que el upstream responda antes, o sube ese timeout. `proxy_ignore_client_abort on` solo esconde el 499 en el log.

### ¿El upstream sabe que el cliente se fue?

En nuestra prueba, no. Nuestro upstream en Python registró 200 en las dos solicitudes que nginx registró como 499, y terminó cada una cuando el cliente ya no estaba.

## Busca cada línea 499 en 1 solo lugar

Envía las líneas de log de nginx a LogBrew como logs OTLP y búscalas desde el panel, la CLI o tu agente de IA. Empieza con el generoso plan gratuito, sin tarjeta.

[Empezar gratis](https://logbrew.co/es)

## Fuentes

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

## Más soluciones a errores

- [Soluciona el error Script error que oculta su mensaje, archivo y línea](https://logbrew.co/es/errors/script-error)
- [Soluciona el error Failed to fetch y distingue sus 3 causas](https://logbrew.co/es/errors/failed-to-fetch)
- [Soluciona java.lang.NullPointerException en Kotlin y Android a partir de su mensaje](https://logbrew.co/es/errors/nullpointerexception)
- [Corrige Minified React error #418 y #185 con el mensaje completo y tu línea de código](https://logbrew.co/es/errors/minified-react-error)
- [Soluciona Cannot use import statement outside a module en el navegador y en Node.js](https://logbrew.co/es/errors/cannot-use-import-statement-outside-a-module)
- [Soluciona AxiosError Network Error y averigua cuál de sus 3 causas tienes](https://logbrew.co/es/errors/axios-network-error)
- [Errores que reproducimos, y cómo solucionar cada uno](https://logbrew.co/es/errors)
