---
title: "Corrija Minified React error #418 e #185 com a mensagem completa e a sua linha de código"
description: "Um Minified React error é um número que substitui uma mensagem mais longa. Abra o link react.dev/errors que ele imprime para ler a mensagem. Disparamos #418 e #185 no Next.js 16 e corrigimos os dois."
canonical: "https://logbrew.co/pt-BR/errors/minified-react-error"
last_updated: "2026-11-20"
---

# Corrija Minified React error #418 e #185 com a mensagem completa e a sua linha de código

Um Minified React error é um número que substitui uma mensagem mais longa. Abra o link `react.dev/errors` que ele imprime para ler a mensagem. Disparamos #418 e #185 no Next.js 16 e corrigimos os dois.

Testado em 20 de novembro de 2026 com Next.js 16.4.6, React 19.2.7, Chrome 157 e @logbrew/next 0.1.18

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

## Quais erros do React um error boundary capturou

| Onde o erro foi lançado | O boundary pegou | Mensagem real no navegador |
| --- | --- | --- |
| Render de um client component | Sim | Sim |
| `useEffect` | Sim | Sim |
| Handler de `onClick` | Não | Sim |
| Callback de `setTimeout` | Não | Sim |
| Handler async, depois de `await` | Não | Sim |
| Server Component | Sim | Não, `#441` e um digest |

6 erros em 1 build de produção do Next.js 16.4.6 com React 19.2.7.

## Leia a mensagem completa e depois ache a linha

### Abra o link da mensagem

O React de produção deixa o texto das mensagens fora do bundle e imprime um número e um link no lugar. Abra o link. A página `react.dev/errors` mostra o texto completo e preenche cada valor de `args[]` a partir da URL. O build de desenvolvimento, que o `next dev` usa, imprime o texto completo direto.

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

Saída

```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 quer dizer que o HTML do servidor não bateu com o primeiro render

O decoder lê #418 como `Hydration failed because the server rendered text didn't match the client`. `args[]=text` quer dizer que um nó de texto estava diferente, como com `Date.now()` acima. `args[]=HTML` quer dizer que os elementos estavam diferentes. Um `<div>` dentro de um `<p>` nos deu `HTML`, porque o navegador fecha o `<p>` antes do `<div>`. Nas 2 execuções o React renderizou a versão do navegador e a página continuou funcionando.

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

Saída

```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 não apareceu no React 19.2

O decoder lê #423 como `There was an error while hydrating but React was able to recover by instead client rendering the entire root.` Criamos 3 divergências no React 19.2.7, 1 delas dentro de `<Suspense>`, e o React imprimiu #418 todas as vezes, nunca #423. Se os seus logs mostram #423, procure as mesmas causas do #418.

### #185 vem de um layout effect que muda o state depois de cada render

O decoder lê #185 como `Maximum update depth exceeded`. Nosso `useLayoutEffect` sem lista de dependências mudava o state depois de cada render, o React parou o loop com #185, e o Next.js trocou a página por `This page couldn’t load`. O mesmo código em `useEffect` não imprimiu erro nenhum. Em 2 execuções o contador marcava 228.936 e 231.224 quando lemos a 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>;
}
```

Saída

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

### Volte do stack para o seu arquivo com o source map

Coloque `productionBrowserSourceMaps: true` no `next.config` e gere o build de novo. O Turbopack dá a cada map um nome próprio com hash, então o `resolve.mjs` lê o nome na última linha do chunk e depois acha a posição com a classe `SourceMap` que vem no Node. Passamos para ele o único frame do stack do #185 fora do React, `2-5_qr0vv7do_.js:1:254`, e ele apontou `setCount` na linha 7 da nossa 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}`);
```

Saída

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

## Corrija a causa e capture o que sobrar

### Corrija o #418 renderizando o mesmo no servidor e no primeiro carregamento

Leia valores que só existem no navegador, como `Date.now()`, `window` ou `localStorage`, dentro de `useEffect`. Ele só roda no navegador, depois da hidratação, então o primeiro render bate com o HTML do servidor, e o #418 sumiu na nossa execução. Para um `<div>` dentro de um `<p>`, troque 1 das 2 tags. Um `<span>` dentro do `<p>` não imprimiu erro nenhum.

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

### Use `suppressHydrationWarning` só para 1 valor que você não consegue igualar

`suppressHydrationWarning` parou o #418 na nossa execução, mas a página ficou com o texto do servidor. Ela mostrava a hora do build, não a hora do navegador. Ele só funciona 1 nível abaixo, e o React o chama de válvula de escape.

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

### Corrija o #185 dando ao effect uma lista de dependências

Com `[]`, o layout effect rodou uma vez e a página mostrou 1, sem erro. Liste os valores que o effect lê e só mude o state quando um deles mudar.

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

### Capture erros de render com um error boundary

Um error boundary é um componente de classe. `getDerivedStateFromError` troca ele para um fallback, e `componentDidCatch` reporta o erro. O nosso pegou o `TypeError` de `taps.map` durante o render e um erro lançado em `useEffect`. Ele deixou passar erros lançados em um handler de `onClick`, em um callback de `setTimeout` e depois de `await` em um handler async. Esses chegaram ao window como erros não capturados, então capture-os onde você os lança.

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

Saída

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

### No Next.js, adicione `error.tsx` e envie o erro para o LogBrew

O Next.js envolve cada segmento de rota em um error boundary que renderiza `error.tsx`. Nosso `error.tsx` pegou o mesmo erro de render, e `captureNextClientError()` do `@logbrew/next` o enviou como 1 problema. A demo passa um transport que grava. Tire o `transport` e o cliente envia para o LogBrew com `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" />;
}
```

Saída

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

## O que vimos no teste

Geramos 1 app Next.js 16.4.6 com React 19.2.7 usando `next build` com Turbopack, servimos com `next start` e abrimos cada página no Chrome 157 headless. Criamos 3 divergências de hidratação, 2 loops de atualização e 6 erros em lugares diferentes, e depois rodamos cada correção no mesmo build.

Toda divergência de hidratação imprimiu #418, nunca #423. Só o loop do layout effect imprimiu #185. O error boundary pegou 3 dos 6 erros, e o navegador viu a mensagem real em 5 deles.

O erro do Server Component é o diferente. A página respondeu 500, e o navegador recebeu `Minified React error #441` com o `digest` `1331393307` em vez da nossa mensagem. O log do servidor imprimiu `Orders database is down` com o mesmo digest, então o digest leva você ao erro real.

Saída

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

## Por que o React de produção imprime números em vez de mensagens

O build de produção do React guarda só o código de cada erro, para enviar menos bytes. Os textos ficam em `scripts/error-codes/codes.json` no repositório do React, e a página do decoder preenche os argumentos a partir da URL. O #441 é diferente. O React tira de propósito a mensagem de um Server Component nos builds de produção, para que detalhes do servidor nunca cheguem ao navegador.

O stack também é minificado. Para o #418, um source map ajuda pouco. Todo frame dos nossos stacks do #418 levava para `react-dom-client.production.js`, nenhum para o nosso código. O valor de `args[]` e o componente que você mudou por último levam mais rápido à causa.

vercel/next.js#50245 mostra por que o texto decodificado importa. O tópico relatou em maio de 2023 Minified React errors que só apareciam em produção. Um maintainer escreveu que as pessoas na thread provavelmente tinham problemas diferentes por trás da mesma mensagem, e o tópico foi fechado em agosto de 2024 sem uma reprodução. A mensagem decodificada e a linha de código separam esses casos.

## O que o LogBrew registra

`captureNextClientError()` enviou 1 problema com o título `TypeError` no nível `error`, com a mensagem, o mecanismo `nextjs.error_boundary` e `handled: false`. Ele guardou 10 frames do stack trace, cada um com arquivo, linha, coluna e função. O primeiro frame era `19k2sxe-2yvvy.js` na linha 1, coluna 220, e o nosso source map o transformou em `taps.map` na linha 5 da página.

O LogBrew agrupa as repetições pelo tipo de erro e por esse primeiro frame, com a chave `nextjs.error_boundary:TypeError:` seguida da URL do chunk. O problema guardou o texto da mensagem, e a entrada da sua cadeia de causas marcou a mensagem como `redacted`.

No erro do Server Component, o problema trazia a mensagem do #441 e o `errorDigest` `1331393307`, o mesmo valor do log do servidor. A cadeia dizia `stackFramesState: "not_captured"`, porque o navegador nunca teve o stack do servidor.

## Perguntas frequentes

### O que é um Minified React error?

Um erro vindo de um build de produção do React. O React troca a mensagem por um número e um link para `react.dev/errors`, e essa página mostra o texto completo. O build de desenvolvimento imprime o texto completo direto.

### O que significa Minified React error #418?

Que a hidratação falhou. O HTML do servidor não bateu com o primeiro render no navegador. `args[]=text` aponta para um nó de texto, e `args[]=HTML` para os elementos. `Date.now()`, checagens de `typeof window`, datas no locale do usuário e um `<div>` dentro de um `<p>` causam esse erro.

### Como corrijo um erro de hidratação em um layout do Next.js?

Ache o que muda entre o servidor e o navegador nesse layout, como em qualquer componente. No root layout, um script de tema ou uma extensão do navegador que muda `<html>` ou `<body>` antes de o React carregar também causa o erro. `suppressHydrationWarning` nesse elemento esconde o erro 1 nível abaixo.

### O que significa Minified React error #185?

Que a profundidade máxima de atualizações foi excedida. Um componente mudou o state de novo e de novo enquanto o React aplicava as atualizações. Na nossa execução, quem causou foi `useLayoutEffect` sem lista de dependências. Adicione uma lista de dependências ou só mude o state quando o valor mudar.

### O que um error boundary não captura?

Na nossa execução, ele deixou passar erros lançados em um handler de `onClick`, em um callback de `setTimeout` e depois de `await`. Ele pegou erros no render, em `useEffect` e de um Server Component, mas este último chegou como #441 sem a mensagem.

### Por que vejo um Minified React error no ChatGPT ou em outro site?

O site roda um build de produção do React, e o código dele bateu em um erro. Só os desenvolvedores do site podem corrigir esse código. Uma extensão do navegador que muda a página antes de o React carregar também pode causar o #418, então teste em uma janela anônima com as extensões desativadas.

## Capture cada erro do React em produção

O SDK Next.js do LogBrew envia cada erro que chega ao error.tsx com os frames do stack trace e o digest do servidor, e o LogBrew agrupa as repetições em 1 problema. Comece no plano gratuito generoso, sem cartão.

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

## Fontes

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

## 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)
- [Erros que reproduzimos, e como corrigir cada um](https://logbrew.co/pt-BR/errors)
