---
title: "Corrige Minified React error #418 y #185 con el mensaje completo y tu línea de código"
description: "Un Minified React error es un número que sustituye a un mensaje más largo. Abre el enlace a react.dev/errors que imprime para leerlo. Provocamos #418 y #185 en Next.js 16 y corregimos los dos."
canonical: "https://logbrew.co/es/errors/minified-react-error"
last_updated: "2026-11-20"
---

# Corrige Minified React error #418 y #185 con el mensaje completo y tu línea de código

Un Minified React error es un número que sustituye a un mensaje más largo. Abre el enlace a `react.dev/errors` que imprime para leerlo. Provocamos #418 y #185 en Next.js 16 y corregimos los dos.

Probado el 20 de noviembre de 2026 con Next.js 16.4.6, React 19.2.7, Chrome 157 y @logbrew/next 0.1.18

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/minified-react-error

## Qué errores de React capturó un error boundary

| Dónde se lanzó el error | El boundary lo capturó | Mensaje real en el navegador |
| --- | --- | --- |
| Render de un componente de cliente | Sí | Sí |
| `useEffect` | Sí | Sí |
| Handler de `onClick` | No | Sí |
| Callback de `setTimeout` | No | Sí |
| Handler async, después de `await` | No | Sí |
| Server Component | Sí | No, `#441` y un digest |

6 errores en 1 build de producción de Next.js 16.4.6 con React 19.2.7.

## Lee el mensaje completo y luego encuentra la línea

### Abre el enlace del mensaje

React en producción deja el texto del mensaje fuera del bundle e imprime un número y un enlace en su lugar. Abre el enlace. La página de `react.dev/errors` muestra el texto completo y rellena cada valor de `args[]` a partir de la URL. El build de desarrollo, el que usa `next dev`, imprime el texto completo directamente.

```bash
"use client";
export function RenderedAt() {
  return <p>Rendered at {Date.now()}</p>;
}
```

Salida

```text
Error: Minified React error #418; visit https://react.dev/errors/418?args[]=text&args[]= for the full message or use the non-minified dev environment for full errors and additional helpful warnings.
```

### #418 significa que el HTML del servidor no coincidió con el primer render

El decoder lee #418 como `Hydration failed because the server rendered text didn't match the client`. `args[]=text` indica que un nodo de texto era distinto, como con `Date.now()` arriba. `args[]=HTML` indica que los elementos eran distintos. Un `<div>` dentro de un `<p>` nos dio `HTML`, porque el navegador cierra el `<p>` antes del `<div>`. En las dos pruebas React renderizó la versión del navegador y la página siguió funcionando.

```bash
export default function Page() { return <p>Order total <div>12 USD</div></p>; }
```

Salida

```text
Error: Minified React error #418; visit https://react.dev/errors/418?args[]=HTML&args[]= for the full message or use the non-minified dev environment for full errors and additional helpful warnings.
```

### #423 no apareció en React 19.2

El decoder lee #423 como `There was an error while hydrating but React was able to recover by instead client rendering the entire root.` Provocamos 3 desajustes en React 19.2.7, 1 de ellos dentro de `<Suspense>`, y React imprimió #418 cada vez, nunca #423. Si tus logs muestran #423, busca las mismas causas que para #418.

### #185 viene de un layout effect que cambia el estado tras cada render

El decoder lee #185 como `Maximum update depth exceeded`. Nuestro `useLayoutEffect` sin lista de dependencias cambiaba el estado después de cada render, React cortó el bucle con #185 y Next.js reemplazó la página por `This page couldn’t load`. El mismo código en `useEffect` no imprimió ningún error. En 2 pruebas el contador marcaba 228.936 y 231.224 cuando leímos la página.

```bash
"use client";
import { useLayoutEffect, useState } from "react";

export default function Page() {
  const [count, setCount] = useState(0);
  useLayoutEffect(() => {
    setCount(count + 1);
  });
  return <p>{count}</p>;
}
```

Salida

```text
Error: Minified React error #185; visit https://react.dev/errors/185 for the full message or use the non-minified dev environment for full errors and additional helpful warnings.
```

### Lleva el stack de vuelta a tu archivo con el source map

Pon `productionBrowserSourceMaps: true` en `next.config` y vuelve a compilar. Turbopack da a cada map su propio nombre con hash, así que `resolve.mjs` lee el nombre de la última línea del chunk y luego busca la posición con la clase `SourceMap` que trae Node. Le pasamos el único frame del stack de #185 fuera de React, `2-5_qr0vv7do_.js:1:254`, y señaló `setCount` en la línea 7 de nuestra página.

```bash
// node resolve.mjs <chunk.js> <line> <column>
import { readFileSync } from "node:fs";
import { SourceMap } from "node:module";
import { dirname, join } from "node:path";

const [chunk, line, column] = process.argv.slice(2);
const mapName = readFileSync(chunk, "utf8").match(/sourceMappingURL=(\S+)\s*$/)[1];
const map = new SourceMap(JSON.parse(readFileSync(join(dirname(chunk), mapName), "utf8")));
const { originalSource, originalLine, originalColumn, name } = map.findEntry(line - 1, column - 1);
console.log(`${name ?? "?"} ${originalSource}:${originalLine + 1}:${originalColumn + 1}`);
```

Salida

```text
setCount turbopack:///[project]/app/loop-layout-effect/page.tsx:7:5
```

## Corrige la causa y captura lo que quede

### Corrige #418 renderizando lo mismo en el servidor y en la primera carga

Lee los valores que solo existen en el navegador, como `Date.now()`, `window` o `localStorage`, dentro de `useEffect`. Se ejecuta solo en el navegador, después de la hidratación, así que el primer render coincide con el HTML del servidor, y #418 desapareció en nuestra prueba. Para un `<div>` dentro de un `<p>`, cambia 1 de las 2 etiquetas. Un `<span>` dentro del `<p>` no imprimió ningún error.

```bash
"use client";
import { useEffect, useState } from "react";

export function RenderedAt() {
  const [renderedAt, setRenderedAt] = useState<number | null>(null);
  useEffect(() => setRenderedAt(Date.now()), []);
  return <p>Rendered at {renderedAt ?? "…"}</p>;
}
```

### Usa `suppressHydrationWarning` solo para 1 valor que no puedas igualar

`suppressHydrationWarning` detuvo #418 en nuestra prueba, pero la página se quedó con el texto del servidor. Mostraba la hora del build, no la hora del navegador. Solo funciona a 1 nivel de profundidad, y React lo describe como una vía de escape.

```bash
"use client";
export function RenderedAt() {
  return <p suppressHydrationWarning>Rendered at {Date.now()}</p>;
}
```

### Corrige #185 dándole al efecto una lista de dependencias

Con `[]`, el layout effect se ejecutó una vez y la página mostró 1, sin errores. Pon en la lista los valores que lee el efecto y cambia el estado solo cuando uno de ellos haya cambiado.

```bash
"use client";
import { useLayoutEffect, useState } from "react";

export default function Page() {
  const [count, setCount] = useState(0);
  useLayoutEffect(() => {
    setCount(count + 1);
  }, []);
  return <p>{count}</p>;
}
```

### Captura los errores de render con un error boundary

Un error boundary es un componente de clase. `getDerivedStateFromError` lo cambia a una interfaz de reserva y `componentDidCatch` reporta el error. El nuestro capturó el `TypeError` de `taps.map` durante el render y un error lanzado en `useEffect`. Se le escaparon los errores lanzados en un handler de `onClick`, en un callback de `setTimeout` y después de `await` en un handler async. Esos llegaron a window como errores no capturados, así que captúralos donde los lanzas.

```bash
"use client";
import { Component, type ReactNode } from "react";

export class ErrorBoundary extends Component<{ children: ReactNode }, { error: Error | null }> {
  state: { error: Error | null } = { error: null };

  static getDerivedStateFromError(error: Error) {
    return { error };
  }

  componentDidCatch(error: Error) {
    console.error("ErrorBoundary caught:", error.message);
  }

  render() {
    if (this.state.error) return <p>This part of the page failed to load.</p>;
    return this.props.children;
  }
}
```

Salida

```text
ErrorBoundary caught: Cannot read properties of undefined (reading 'map')
```

### En Next.js, añade `error.tsx` y envía el error a LogBrew

Next.js envuelve cada segmento de ruta en un error boundary que renderiza `error.tsx`. Nuestro `error.tsx` capturó el mismo error de render, y `captureNextClientError()` de `@logbrew/next` lo envió como 1 incidencia. La demo pasa un transport que graba. Quita `transport` y el cliente enviará a LogBrew con `fetch`.

```bash
// app/next-error.tsx
"use client";
import { useEffect } from "react";
import { captureNextClientError, createLogBrewNextBrowserClient } from "@logbrew/next/client";
import { RecordingTransport } from "@logbrew/sdk";

const transport = RecordingTransport.alwaysAccept();
const logbrew = createLogBrewNextBrowserClient({
  clientKey: process.env.NEXT_PUBLIC_LOGBREW_CLIENT_KEY,
  transport
});

export function ReportError({ error, route }: { error: Error & { digest?: string }; route: string }) {
  useEffect(() => {
    void captureNextClientError(logbrew, error, { routeTemplate: route }).then((response) => {
      console.log(JSON.stringify(response));
      console.log(transport.lastBody());
    });
  }, [error, route]);
  return <p>This page failed to load.</p>;
}

// app/next-boundary/error.tsx
"use client";
import { ReportError } from "../next-error";

export default function Error({ error }: { error: Error & { digest?: string } }) {
  return <ReportError error={error} route="/next-boundary" />;
}
```

Salida

```text
{"statusCode":202,"attempts":1,"batches":1}
```

## Lo que vimos al probarlo

Compilamos 1 app de Next.js 16.4.6 con React 19.2.7 usando `next build` con Turbopack, la servimos con `next start` y abrimos cada página en Chrome 157 headless. Provocamos 3 desajustes de hidratación, 2 bucles de actualización y 6 errores en sitios distintos, y luego probamos cada corrección en el mismo build.

Cada desajuste de hidratación imprimió #418, nunca #423. Solo el bucle del layout effect imprimió #185. El error boundary capturó 3 de los 6 errores, y el navegador vio el mensaje real en 5 de ellos.

El error del Server Component es el raro. La página respondió con 500, y el navegador recibió `Minified React error #441` con el `digest` `1331393307` en vez de nuestro mensaje. El log del servidor imprimió `Orders database is down` con el mismo digest, así que el digest te lleva al error real.

Salida

```text
⨯ Error: Orders database is down
    at b (.next/server/chunks/ssr/[root-of-the-server]__0e6swfn4zoar-._.js:1:1281) {
  digest: '1331393307'
}
```

## Por qué React en producción imprime números en vez de mensajes

El build de producción de React guarda solo el código de cada error para enviar menos bytes. Los textos están en `scripts/error-codes/codes.json` en el repositorio de React, y la página del decoder rellena los argumentos desde la URL. #441 es distinto. React deja fuera a propósito el mensaje de un Server Component en los builds de producción, para que los detalles del servidor nunca lleguen al navegador.

El stack también está minificado. Para #418, un source map ayuda poco. Cada frame de nuestros stacks de #418 apuntaba a `react-dom-client.production.js` y ninguno a nuestro código. El valor de `args[]` y el componente que cambiaste por última vez te llevan antes a la causa.

vercel/next.js#50245 muestra por qué importa el texto descifrado. En mayo de 2023 reportó Minified React errors que solo aparecían en producción. Un maintainer escribió que la gente del hilo probablemente tenía problemas distintos detrás del mismo mensaje, y la incidencia se cerró en agosto de 2024 sin una reproducción. El mensaje descifrado y la línea de código distinguen esos casos.

## Lo que LogBrew registra

`captureNextClientError()` envió 1 incidencia con el título `TypeError` y nivel `error`, con el mensaje, el mecanismo `nextjs.error_boundary` y `handled: false`. Guardó 10 frames de pila, cada uno con archivo, línea, columna y función. El primer frame era `19k2sxe-2yvvy.js` en la línea 1, columna 220, y nuestro source map lo convirtió en `taps.map` en la línea 5 de la página.

LogBrew agrupa las repeticiones por tipo de error y por ese primer frame, con la clave `nextjs.error_boundary:TypeError:` seguida de la URL del chunk. La incidencia guardó el texto del mensaje, y la entrada de su cadena de causas marcó el mensaje como `redacted`.

Para el error del Server Component, la incidencia llevaba el mensaje de #441 y el `errorDigest` `1331393307`, el mismo valor que en el log del servidor. La cadena indicaba `stackFramesState: "not_captured"`, porque el navegador nunca tuvo el stack del servidor.

## Preguntas frecuentes

### ¿Qué es un Minified React error?

Un error de un build de producción de React. React sustituye el mensaje por un número y un enlace a `react.dev/errors`, y esa página muestra el texto completo. El build de desarrollo imprime el texto completo directamente.

### ¿Qué significa Minified React error #418?

Que la hidratación falló. El HTML del servidor no coincidió con el primer render en el navegador. `args[]=text` apunta a un nodo de texto y `args[]=HTML` a los elementos. Lo causan `Date.now()`, las comprobaciones de `typeof window`, las fechas en el locale del usuario y un `<div>` dentro de un `<p>`.

### ¿Cómo corrijo un error de hidratación en un layout de Next.js?

Busca qué cambia entre el servidor y el navegador en ese layout, como en cualquier componente. En el root layout también lo causa un script de tema o una extensión del navegador que cambia `<html>` o `<body>` antes de que cargue React. `suppressHydrationWarning` en ese elemento oculta el error a 1 nivel de profundidad.

### ¿Qué significa Minified React error #185?

Que se superó la profundidad máxima de actualizaciones. Un componente cambió el estado una y otra vez mientras React aplicaba sus actualizaciones. En nuestra prueba lo causó `useLayoutEffect` sin lista de dependencias. Añade una lista de dependencias o cambia el estado solo cuando el valor haya cambiado.

### ¿Qué no captura un error boundary?

En nuestra prueba se le escaparon los errores lanzados en un handler de `onClick`, en un callback de `setTimeout` y después de `await`. Capturó los errores en el render, en `useEffect` y de un Server Component, pero este último llegó como #441 sin su mensaje.

### ¿Por qué veo un Minified React error en ChatGPT o en otra web?

La web usa un build de producción de React y su código chocó con un error. Solo sus desarrolladores pueden corregir ese código. Una extensión del navegador que cambia la página antes de que cargue React también puede causar #418, así que prueba una ventana privada con las extensiones desactivadas.

## Captura cada error de React en producción

El SDK de Next.js de LogBrew envía cada error que llega a error.tsx con sus frames de pila y el digest del servidor, y LogBrew agrupa las repeticiones en 1 incidencia. Empieza con el generoso plan gratuito, sin tarjeta.

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

## Fuentes

- [React docs, Error decoder](https://react.dev/errors)
- [React docs, Catching rendering errors with an error boundary](https://react.dev/reference/react/Component#catching-rendering-errors-with-an-error-boundary)
- [React docs, Common props (suppressHydrationWarning)](https://react.dev/reference/react-dom/components/common#common-props)
- [Next.js docs, Text content does not match server-rendered HTML](https://nextjs.org/docs/messages/react-hydration-error)
- [Next.js docs, error.js](https://nextjs.org/docs/app/api-reference/file-conventions/error)
- [Next.js docs, productionBrowserSourceMaps](https://nextjs.org/docs/app/api-reference/config/next-config-js/productionBrowserSourceMaps)
- [vercel/next.js#50245](https://github.com/vercel/next.js/issues/50245)

## 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)
- [Errores que reproducimos, y cómo solucionar cada uno](https://logbrew.co/es/errors)
