---
title: "Minified React error #418 und #185 beheben, mit der vollen Meldung und deiner Quellzeile"
description: "Ein Minified React error ist eine Nummer, die für eine längere Meldung steht. Öffne den react.dev/errors-Link, den er ausgibt, um sie zu lesen. Wir haben #418 und #185 in Next.js 16 ausgelöst und beide behoben."
canonical: "https://logbrew.co/de/errors/minified-react-error"
last_updated: "2026-11-20"
---

# Minified React error #418 und #185 beheben, mit der vollen Meldung und deiner Quellzeile

Ein Minified React error ist eine Nummer, die für eine längere Meldung steht. Öffne den `react.dev/errors`-Link, den er ausgibt, um sie zu lesen. Wir haben #418 und #185 in Next.js 16 ausgelöst und beide behoben.

Getestet am 20. November 2026 mit Next.js 16.4.6, React 19.2.7, Chrome 157 und @logbrew/next 0.1.18

Von [Furkan Erday](https://github.com/furkanerday). Furkan Erday hat LogBrew gegründet. Er entwickelt LogBrew jeden Tag mit Claude Code und Codex.

Canonical: https://logbrew.co/de/errors/minified-react-error

## Welche React-Fehler eine Error Boundary abfing

| Wo der Fehler geworfen wurde | Boundary fing ihn | Echte Meldung im Browser |
| --- | --- | --- |
| Render einer Client Component | Ja | Ja |
| `useEffect` | Ja | Ja |
| `onClick`-Handler | Nein | Ja |
| `setTimeout`-Callback | Nein | Ja |
| Async Handler, nach `await` | Nein | Ja |
| Server Component | Ja | Nein, `#441` und ein Digest |

6 Fehler in 1 Production-Build mit Next.js 16.4.6 und React 19.2.7.

## Erst die volle Meldung lesen, dann die Zeile finden

### Den Link in der Meldung öffnen

Production-React lässt den Meldungstext aus dem Bundle weg und gibt stattdessen eine Nummer und einen Link aus. Öffne den Link. Die Seite unter `react.dev/errors` zeigt den vollen Text und setzt jeden `args[]`-Wert aus der URL ein. Der Development-Build, den `next dev` nutzt, gibt den vollen Text direkt aus.

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

Ausgabe

```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 heißt, dass das Server-HTML nicht zum ersten Render passte

Der Decoder liest #418 als `Hydration failed because the server rendered text didn't match the client`. `args[]=text` heißt, dass ein Textknoten anders war, wie bei `Date.now()` oben. `args[]=HTML` heißt, dass die Elemente anders waren. Ein `<div>` in einem `<p>` ergab bei uns `HTML`, weil der Browser das `<p>` vor dem `<div>` schließt. In beiden Läufen renderte React die Browser-Version, und die Seite lief weiter.

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

Ausgabe

```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 kam auf React 19.2 nicht vor

Der Decoder liest #423 als `There was an error while hydrating but React was able to recover by instead client rendering the entire root.` Wir haben auf React 19.2.7 3 Abweichungen erzeugt, 1 davon in `<Suspense>`, und React gab jedes Mal #418 aus, nie #423. Zeigen deine Logs #423, such nach denselben Ursachen wie bei #418.

### #185 kommt von einem Layout-Effect, der nach jedem Render State setzt

Der Decoder liest #185 als `Maximum update depth exceeded`. Unser `useLayoutEffect` ohne Dependency-Liste setzte nach jedem Render State, React stoppte die Schleife mit #185, und Next.js ersetzte die Seite durch `This page couldn’t load`. Derselbe Code in `useEffect` gab gar keinen Fehler aus. In 2 Läufen zeigte der Zähler 228.936 und 231.224, als wir die Seite lasen.

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

Ausgabe

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

### Den Stack mit der Source Map auf deine Datei zurückführen

Setz `productionBrowserSourceMaps: true` in `next.config` und baue neu. Turbopack gibt jeder Map einen eigenen Hash-Namen, deshalb liest `resolve.mjs` den Namen aus der letzten Zeile des Chunks und sucht die Position dann mit der in Node eingebauten Klasse `SourceMap`. Wir gaben ihm den 1 Frame des #185-Stacks außerhalb von React, `2-5_qr0vv7do_.js:1:254`, und es nannte `setCount` in Zeile 7 unserer Seite.

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

Ausgabe

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

## Die Ursache beheben, dann den Rest abfangen

### #418 beheben, indem Server und erster Load dasselbe rendern

Lies Werte, die es nur im Browser gibt, wie `Date.now()`, `window` oder `localStorage`, in `useEffect`. Der Effect läuft nur im Browser, nach der Hydration. So passt der erste Render zum Server-HTML, und #418 war in unserem Lauf weg. Bei einem `<div>` in einem `<p>` änderst du 1 der 2 Tags. Ein `<span>` im `<p>` gab keinen Fehler aus.

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

### `suppressHydrationWarning` nur für 1 Wert nutzen, den du nicht angleichen kannst

`suppressHydrationWarning` stoppte #418 in unserem Lauf, aber die Seite behielt den Server-Text. Die Seite zeigte die Zeit des Builds, nicht die Zeit im Browser. Es wirkt nur 1 Ebene tief, und React nennt es eine Notlösung.

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

### #185 beheben, indem der Effect eine Dependency-Liste bekommt

Mit `[]` lief der Layout-Effect einmal, und die Seite zeigte 1, ohne Fehler. Gib die Werte an, die der Effect liest, und setze State nur, wenn sich einer davon geändert hat.

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

### Render-Fehler mit einer Error Boundary abfangen

Eine Error Boundary ist eine Klassenkomponente. `getDerivedStateFromError` schaltet sie auf einen Fallback um, und `componentDidCatch` meldet den Fehler. Unsere fing den `TypeError` aus `taps.map` beim Render und einen Fehler aus `useEffect`. Die Boundary verpasste Fehler aus einem `onClick`-Handler, aus einem `setTimeout`-Callback und nach `await` in einem async Handler. Diese kamen als nicht abgefangene Fehler beim window an, also fang sie dort ab, wo du sie wirfst.

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

Ausgabe

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

### In Next.js `error.tsx` anlegen und den Fehler an LogBrew senden

Next.js packt jedes Route-Segment in eine Error Boundary, die `error.tsx` rendert. Unsere `error.tsx` fing denselben Render-Fehler, und `captureNextClientError()` aus `@logbrew/next` sendete ihn als 1 Issue. Die Demo übergibt einen aufzeichnenden Transport. Lass `transport` weg, dann sendet der Client mit `fetch` an LogBrew.

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

Ausgabe

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

## Was wir beim Testen gesehen haben

Wir haben 1 Next.js-16.4.6-App mit React 19.2.7 per `next build` mit Turbopack gebaut, mit `next start` ausgeliefert und jede Seite in Headless Chrome 157 geöffnet. Wir haben 3 Hydration-Abweichungen, 2 Update-Schleifen und 6 Fehler an verschiedenen Stellen erzeugt und dann jede Lösung auf demselben Build laufen lassen.

Jede Hydration-Abweichung gab #418 aus, nie #423. Nur die Schleife im Layout-Effect gab #185 aus. Die Error Boundary fing 3 der 6 Fehler, und der Browser sah bei 5 davon die echte Meldung.

Der Fehler in der Server Component fällt aus der Reihe. Die Seite antwortete mit 500, und der Browser bekam statt unserer Meldung `Minified React error #441` mit dem `digest` `1331393307`. Das Server-Log zeigte `Orders database is down` mit demselben Digest, also führt dich der Digest zum echten Fehler.

Ausgabe

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

## Warum Production-React Nummern statt Meldungen ausgibt

Der Production-Build von React behält von jedem Fehler nur den Code, um weniger Bytes zu senden. Die Texte stehen in `scripts/error-codes/codes.json` im React-Repository, und die Decoder-Seite setzt die Argumente aus der URL ein. #441 ist anders. React lässt die Meldung einer Server Component in Production-Builds absichtlich weg, damit Details vom Server nie den Browser erreichen.

Auch der Stack ist minifiziert. Bei #418 hilft eine Source Map kaum. Jeder Frame unserer #418-Stacks führte in `react-dom-client.production.js`, keiner in unseren Code. Der `args[]`-Wert und die Komponente, die du zuletzt geändert hast, führen schneller zur Ursache.

vercel/next.js#50245 zeigt, warum der entschlüsselte Text zählt. Das Issue meldete im Mai 2023 Minified React errors, die nur in Production auftraten. Ein Maintainer schrieb, dass die Leute im Thread hinter derselben Meldung wahrscheinlich verschiedene Probleme hatten, und das Issue wurde im August 2024 ohne Reproduktion geschlossen. Die entschlüsselte Meldung und die Quellzeile trennen solche Fälle.

## Was LogBrew aufzeichnet

`captureNextClientError()` sendete 1 Issue mit dem Titel `TypeError` auf Level `error`, mit der Meldung, dem Mechanismus `nextjs.error_boundary` und `handled: false`. Es behielt 10 Stackframes, jeder mit Datei, Zeile, Spalte und Funktion. Der erste Frame war `19k2sxe-2yvvy.js` in Zeile 1, Spalte 220, und unsere Source Map machte daraus `taps.map` in Zeile 5 der Seite.

LogBrew gruppiert Wiederholungen nach Fehlertyp und diesem ersten Frame, mit dem Schlüssel `nextjs.error_boundary:TypeError:` und danach der Chunk-URL. Das Issue behielt den Meldungstext, und der Eintrag in seiner Ursachenkette markierte die Meldung als `redacted`.

Beim Fehler in der Server Component trug das Issue die #441-Meldung und den `errorDigest` `1331393307`, denselben Wert wie im Server-Log. Die Kette meldete `stackFramesState: "not_captured"`, weil der Browser den Server-Stack nie hatte.

## Häufige Fragen

### Was ist ein Minified React error?

Ein Fehler aus einem Production-Build von React. React ersetzt die Meldung durch eine Nummer und einen Link zu `react.dev/errors`, und diese Seite zeigt den vollen Text. Der Development-Build gibt den vollen Text direkt aus.

### Was bedeutet Minified React error #418?

Die Hydration ist fehlgeschlagen. Das HTML vom Server passte nicht zum ersten Render im Browser. `args[]=text` zeigt auf einen Textknoten, `args[]=HTML` auf die Elemente. `Date.now()`, Prüfungen mit `typeof window`, Datumsangaben im Locale des Nutzers und ein `<div>` in einem `<p>` lösen ihn aus.

### Wie behebe ich einen Hydration-Fehler in einem Next.js-Layout?

Finde heraus, was sich in diesem Layout zwischen Server und Browser unterscheidet, wie bei jeder Komponente. Im Root-Layout löst ihn auch ein Theme-Script oder eine Browser-Erweiterung aus, die `<html>` oder `<body>` ändert, bevor React lädt. `suppressHydrationWarning` an diesem Element blendet den Fehler 1 Ebene tief aus.

### Was bedeutet Minified React error #185?

Die maximale Update-Tiefe wurde überschritten. Eine Komponente setzte immer wieder State, während React seine Updates anwandte. In unserem Lauf lag es an `useLayoutEffect` ohne Dependency-Liste. Füg eine Dependency-Liste hinzu oder setze State nur, wenn sich der Wert geändert hat.

### Was fängt eine Error Boundary nicht ab?

In unserem Lauf verpasste sie Fehler aus einem `onClick`-Handler, aus einem `setTimeout`-Callback und nach `await`. Die Boundary fing Fehler im Render, in `useEffect` und aus einer Server Component, aber der letzte kam als #441 ohne seine Meldung an.

### Warum sehe ich einen Minified React error auf ChatGPT oder einer anderen Website?

Die Website nutzt einen Production-Build von React, und ihr Code ist auf einen Fehler gestoßen. Nur ihre Entwickler können diesen Code beheben. Eine Browser-Erweiterung, die die Seite ändert, bevor React lädt, kann auch #418 auslösen. Probier also ein privates Fenster ohne Erweiterungen.

## Jeden React-Fehler in Production abfangen

Das LogBrew-Next.js-SDK sendet jeden Fehler, der error.tsx erreicht, mit seinen Stackframes und dem Server-Digest, und LogBrew gruppiert Wiederholungen in 1 Issue. Starte mit dem großzügigen kostenlosen Plan, ohne Kreditkarte.

[Kostenlos starten](https://logbrew.co/de)

## Quellen

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

## Weitere Fehler beheben

- [Den Script error beheben, der Meldung, Datei und Zeile verbirgt](https://logbrew.co/de/errors/script-error)
- [Den Fehler Failed to fetch beheben und seine 3 Ursachen unterscheiden](https://logbrew.co/de/errors/failed-to-fetch)
- [java.lang.NullPointerException in Kotlin und Android aus der Meldung beheben](https://logbrew.co/de/errors/nullpointerexception)
- [Fehler, die wir reproduziert haben, und wie du jeden behebst](https://logbrew.co/de/errors)
