---
title: "Reading Minecraft Server Logs and Crash Reports"
description: "Find latest.log and crash reports, read a stack trace to name the bad mod or plugin, decode the common startup errors, and bisect a broken server."
url: "https://www.gameserverkings.com/knowledge-base/minecraft/reading-crash-logs-and-common-errors/"
category: "Minecraft"
category_url: "https://www.gameserverkings.com/knowledge-base/minecraft/"
published: "2026-08-19T04:53:32.101Z"
updated: "2026-08-19T08:02:54.749Z"
source_format: "markdown"
site: "GameServerKings"
---

# Reading Minecraft Server Logs and Crash Reports

A Minecraft server that will not start has almost always already told you why — in one line, buried in a few hundred lines of normal startup output. This guide covers where that output lives, how to read a stack trace well enough to name the mod or plugin at fault, how to find a bad one by bisection when the log does not name it, and the specific errors you are most likely to hit.

It applies to any Java Edition server on your [Minecraft server](/games/minecraft/) — vanilla, Paper, Purpur, Fabric, Forge or NeoForge; [Minecraft Server Software Compared](/knowledge-base/minecraft/choosing-server-software/) covers the differences between them. For the separate problem of a server that starts fine but nobody can join, see [Minecraft Players Can't Connect](/knowledge-base/minecraft/players-cant-connect/).

## Where the Output Lives

There are four places to look, and they hold different things.

| Location | Holds | Use it for |
|---|---|---|
| **Console** tab in the panel | Live output from the running process | Watching a start attempt in real time |
| `logs/latest.log` | The current run, from the first line | Anything you missed, and everything before a crash |
| `logs/YYYY-MM-DD-N.log.gz` | Previous runs, gzip-compressed | The run that actually broke, after you restarted |
| `crash-reports/crash-<timestamp>-server.txt` | A full crash report, written only when the server crashes | Hard crashes and watchdog kills |

Two things about that table matter more than the rest:

- **The Console tab only shows the current session.** Restart the server and the evidence you needed scrolls away. `logs/latest.log` does not — open it in the File Manager, or pull it down over SFTP ([How to upload files via SFTP](/knowledge-base/general/how-to-upload-files-via-sftp/) covers the connection).
- **Rotated logs are gzipped.** If the failure was two restarts ago, the log you want is a `.log.gz`, not `latest.log`. Download it and open it locally.

![The Console tab showing live output from a server start](<https://cdn.gskinternal.com/articles/images/minecraft-server-console.png>)

A crash report is written only for a genuine crash, not for every error. When one is produced, the console says so:

```text title="Console output"
[Server thread/ERROR]: This crash report has been saved to: ./crash-reports/crash-2026-08-19_04.11.32-server.txt
```

The file itself opens like this:

```text title="crash-reports/crash-2026-08-19_04.11.32-server.txt"
---- Minecraft Crash Report ----
// I let you down. Sorry :(

Time: 2026-08-19 04:11:32
Description: Exception in server tick loop

java.lang.NullPointerException: Cannot invoke "..." because "..." is null
	at ...
```

The comment line after the header is one of a rotating set of jokes Mojang ships with the game; ignore it. **`Description:` is the field that matters** — it names the phase the server died in. `Exception in server tick loop`, `Exception ticking world` and `Watching Server` (the watchdog) are the three you will see most.

## How to Read a Stack Trace

A stack trace is one exception line followed by a stack of `at` lines. Read it in this order.

**1. The top line: what actually went wrong.**

```text
java.lang.OutOfMemoryError: Java heap space
```

Everything before the colon is the exception type. Everything after it is the message. Together they are what you search for, and what you quote in a ticket.

**2. The `at` lines: where it went wrong.** Read them top-down and stop at the first line that is not `net.minecraft`, `org.bukkit` or `java.base` — that package name is usually the culprit.

```text
java.lang.NullPointerException: Cannot read field "level" because "entity" is null
	at com.example.grieflog.EntityListener.onDeath(EntityListener.java:88)   <-- this one
	at org.bukkit.plugin.java.JavaPluginLoader$1.execute(JavaPluginLoader.java:306)
	at net.minecraft.server.level.ServerLevel.tick(ServerLevel.java:412)
```

`com.example.grieflog` is a third-party package, so GriefLog is the plugin to update or remove. PaperMC's own [basic troubleshooting guide](https://docs.papermc.io/paper/basic-troubleshooting/) puts it plainly: in most cases the plugin whose name appears in the stack trace is the one causing the problem.

**3. `Caused by:` — read to the bottom.** When a trace has one or more `Caused by:` blocks, the **last** one is the real fault. The blocks above it are just wrappers.

```text
java.lang.RuntimeException: Failed to load plugin
	at ...
Caused by: java.lang.NoClassDefFoundError: net/milkbowl/vault/economy/Economy
```

`NoClassDefFoundError` on a class from another project means a missing dependency — here, Vault.

> [!TIP] Read from the bottom of the log, not the top
> Startup output is long and mostly uninteresting. Open `latest.log`, jump to the end, and scroll *up* until you find the first `ERROR` or `Caused by:`. The last thing the server said before it stopped is nearly always the reason it stopped.

## Startup Errors, in the Order You Hit Them

### `You need to agree to the EULA`

```text title="Console output"
[ServerMain/WARN]: Failed to load eula.txt
[ServerMain/INFO]: You need to agree to the EULA in order to run the server. Go to eula.txt for more info.
```

The server generates `eula.txt` on its very first run and exits:

```properties title="eula.txt"
#By changing the setting below to TRUE you are indicating your agreement to our EULA (https://aka.ms/MinecraftEULA).
#[Generation time]
eula=false
```

Change `eula=false` to `eula=true` in the File Manager and start again. The `Failed to load eula.txt` warning on a brand-new server is normal — the file did not exist yet.

### `FAILED TO BIND TO PORT!`

```text title="Console output"
[Server thread/WARN]: **** FAILED TO BIND TO PORT!
[Server thread/WARN]: The exception was: java.net.BindException: Address already in use
[Server thread/WARN]: Perhaps a server is already running on that port?
```

The server could not take the port it was told to listen on. On managed hosting there are two realistic causes:

- **The old process is still running.** A stop that did not complete leaves the port held. Use **Restart**, or stop and wait for the console to confirm it exited before starting again.
- **`server-ip` or `server-port` was edited by hand.** Both are managed by the panel. `server-ip` should stay empty, which means "listen on every interface"; the Minecraft Wiki names an address in `server-ip` that the machine does not own as the single most common cause of this error. `server-port` must stay on your panel allocation — the panel syncs it on boot, so a hand-edited value only breaks the next start.

### `UnsupportedClassVersionError` — Wrong Java Version

This one has become common, because Minecraft moved its Java requirement in 2026 and a lot of servers were carried across without their runtime.

```text title="Console output"
Exception in thread "ServerMain" java.lang.UnsupportedClassVersionError: net/minecraft/bundler/Main has been compiled by a more recent version of the Java Runtime (class file version 69.0), this version of the Java Runtime only recognizes class file versions up to 65.0
```

Read the two numbers. The first is what the jar needs; the second is what your runtime provides. Both are *class file* versions, not Java versions, and the conversion is simply **Java version + 44**:

| Class file version | Java version | Minecraft releases that need it |
|---|---|---|
| 52.0 | Java 8 | 1.12 through 1.16.5 |
| 60.0 | Java 16 | 1.17, 1.17.1 |
| 61.0 | Java 17 | 1.18 through 1.20.4 |
| 65.0 | Java 21 | 1.20.5 through 1.21.11 |
| 69.0 | Java 25 | **26.1 and newer** |

So `69.0` needed, `65.0` available means a 26.x server jar on a Java 21 runtime. Mojang publishes the requirement per version in its own version manifest — the 26.2 entry carries `"java_version": 25` — and PaperMC states the same minimum in its [getting started guide](https://docs.papermc.io/paper/getting-started). The Minecraft Wiki's [server setup tutorial](https://minecraft.wiki/w/Tutorial:Setting_up_a_Java_Edition_server) lists the same thresholds, and [Updating Your Minecraft Server](/knowledge-base/minecraft/updating-your-server-version/) covers moving a live server across a Java boundary safely.

**The fix is to raise the Java version on the Startup tab**, not to downgrade Minecraft. Note that the reverse does not happen: newer Java runs older Minecraft happily, so there is no such thing as being "too new" for this error.

> [!WARNING] Plugins and mods hit this too
> The class name at the front of the message tells you who compiled too new. `net/minecraft/bundler/Main` on a vanilla jar, or `org/bukkit/craftbukkit/Main` on Paper, is the server itself. Anything else — `com/example/someplugin/Main` — is a plugin or mod built for a newer Java than your server runs, and the fix is a build of that plugin for your version rather than a change on the Startup tab.

### `OutOfMemoryError`

```text title="Console output"
[Server thread/ERROR]: Encountered an unexpected exception
java.lang.OutOfMemoryError: Java heap space
```

The JVM ran out of heap. Three variants mean slightly different things:

| Message | Meaning |
|---|---|
| `java.lang.OutOfMemoryError: Java heap space` | The normal one. The heap is too small for the workload |
| `java.lang.OutOfMemoryError: GC overhead limit exceeded` | The heap is technically not full, but garbage collection is running constantly and achieving nothing. Same fix |
| `java.lang.OutOfMemoryError: unable to create native thread` | Not heap at all — the process hit a limit *outside* the heap. Thread stacks, metaspace and direct byte buffers share the container's memory with the heap, and something has exhausted that margin |

You are genuinely out of memory in all three cases, but the remedy on a GameServerKings server is not the one most guides give. There is no `Xmx` field on the **Startup** tab to raise or lower — your server launches with `-XX:MaxRAMPercentage=95.0`, so the heap is already 95% of the RAM your plan provides, and the remaining 5% is the off-heap margin the third message is complaining about. That leaves two real levers:

- **Give the server less to hold.** Lower `view-distance` and `simulation-distance` in `server.properties`, cull accumulated entities, and drop plugins or mods you are not using. Each of those shrinks the live set the heap has to keep.
- **Move to a larger plan.** The heap ceiling is defined as a percentage of your allocation, so a bigger allocation is the only way to raise it.

For the third message specifically, also look for a plugin spawning threads without limit — it is the one OOM variant that is often a single misbehaving add-on rather than a sizing problem. [Minecraft Server RAM and JVM Flags](/knowledge-base/minecraft/allocating-ram-and-jvm-flags/) explains how the heap figure is arrived at.

A crash is not the only symptom. A server running slowly out of memory lags heavily and logs repeated GC pauses long before it finally dies, so an OOM crash after hours of complaints is normal.

### `Failed to load datapacks`

```text title="Console output"
[Server thread/ERROR]: Failed to load datapacks, can't proceed with server load. You can either fix your datapacks or reset to vanilla with --safeMode
```

A datapack in `world/datapacks/` is malformed, or was built for a different pack format than your Minecraft version uses. Remove the pack you added most recently and restart.

### `Failed to load world data` and Chunk Corruption

The blunt one, which stops the boot outright:

```text title="Console output"
[Server thread/ERROR]: Failed to load world data. World files may be corrupted. Shutting down.
```

The subtler ones appear during play, chunk by chunk, and are worth catching early:

| Message | Meaning |
|---|---|
| `Chunk file at [12, -7] is missing level data, skipping` | That chunk's data is unreadable and will be regenerated empty |
| `Region file .../r.0.-1.mca has truncated header: 3072` | The region file was cut short — usually an unclean shutdown mid-write |
| `Chunk [21, 7] stream is truncated: expected 4096 but read 1832` | Same, at chunk granularity |
| `Chunk file at [5, 9] is in the wrong location; relocating. (Expected ..., got ...)` | Region files were shuffled between folders. The server repairs this itself |
| `Failed to read chunk [x, z]` | Generic read failure; check the accompanying stack trace |

Genuine corruption is usually caused by a hard kill during a save, or by running out of disk. Restore from a backup — [How to create a backup](/knowledge-base/general/how-to-create-a-backup/) — rather than trying to repair region files by hand. `sync-chunk-writes` defaults to `true` precisely to prevent this class of damage, and is not something to switch off casually; [Minecraft World Management](/knowledge-base/minecraft/world-management/) covers world files in depth.

One special case is worth its own line, because it is not corruption at all:

```text
java.lang.RuntimeException: Server attempted to load chunk saved with newer version of minecraft! 3955 > 3465
```

That is a **downgrade**. The world was opened by a newer Minecraft version than the server is now running, and the two numbers are world data versions, not Minecraft versions — 26.2 writes `4903`. Minecraft does not support downgrading a world. Put the server back on the version that wrote it, or restore a backup taken before the upgrade; [Updating Your Minecraft Server](/knowledge-base/minecraft/updating-your-server-version/) covers doing this in the right order.

### Mixin Failures

Mixin is the bytecode-patching library that Fabric mods and many NeoForge mods use to modify the game. When two mods patch the same method incompatibly, or a mod was built for a different Minecraft version, Mixin refuses:

```text title="Console output"
Mixin [examplemod.mixins.json:MinecraftServerMixin] from phase [DEFAULT] in config [examplemod.mixins.json] FAILED during APPLY
org.spongepowered.asm.mixin.injection.throwables.InvalidInjectionException: Critical injection failure: @Inject annotation on init could not find any targets matching 'tickServer' in net.minecraft.server.MinecraftServer
```

The pieces to read:

- **The config name** — `examplemod.mixins.json` — names the mod. That is your culprit, every time. On NeoForge the loader logs `Failed to apply mixin. Mixin Class: <class>, ModID: <modid>` alongside it, naming the mod ID directly.
- **`could not find any targets matching`** means the mod is patching a method that does not exist in this Minecraft version. It is built for a different version. Update it, or move the server back.
- **`failed injection check`** in the same family means the mod found fewer injection points than it required — usually another mod got there first.
- **`Mixin config X requires mixin subsystem version Y but Z was found`** means your loader is older than the mod expects. Update Fabric Loader or NeoForge.

Related failure types logged the same way are `InvalidMixinException`, `MixinApplyError` and `MixinPrepareError`; the diagnosis is identical — find the config name, find the mod.

### Missing Dependencies

Fabric refuses to launch on an unsatisfied dependency and tells you exactly what to install:

```text title="Console output"
Incompatible mods found!
	- mod 'Example Mod' (examplemod) 3.2.0 requires any version of fabric-api, which is missing!
A potential solution has been determined, this may resolve your problem:
	- Install Fabric API, any version.
```

`requires ... which is missing!` means install it. `requires ... but only the wrong version is present` means update it. Fabric prints the suggested fix under **A potential solution has been determined** — follow it literally.

The plugin equivalent on Paper and Spigot is shorter but means the same thing:

```text title="Console output"
[Server thread/ERROR]: Could not load 'ExamplePlugin.jar' in folder 'plugins'
org.bukkit.plugin.UnknownDependencyException: Unknown/missing dependency plugins: [Vault]. Please download and install these plugins to run 'ExamplePlugin'.
```

The message names both the missing plugin and the one that wanted it. The common shared dependencies are Vault, ProtocolLib and PlaceholderAPI. See [How to install plugins for Minecraft Java Edition](/knowledge-base/minecraft/java-plugins/).

Paper has one more of its own worth recognising, because the message is unusually clear about what to do:

```text title="Console output"
[SimpleProviderStorage] Circular plugin loading detected!
[SimpleProviderStorage] Circular load order: PluginA -> PluginB -> PluginC -> PluginA
```

Two or more plugins declare each other as dependencies. Update the plugins named in that loop.

## Crashes After the Server Is Running

### The Watchdog

If a single tick takes longer than `max-tick-time` — 60,000 ms by default — the server assumes it has hung and kills itself:

```text title="Console output"
[Server Watchdog/ERROR]: A single server tick took 60.00 seconds (should be max 0.05)
[Server Watchdog/ERROR]: Considering it to be crashed, server will forcibly shutdown.
```

Paper's watchdog trips much earlier and prints a thread dump instead of a crash, with a banner designed to stop people filing bug reports:

```text title="Console output"
[Paper Watchdog Thread/ERROR]: --- DO NOT REPORT THIS TO PAPER - THIS IS NOT A BUG OR A CRASH ---
[Paper Watchdog Thread/ERROR]: The server has not responded for 10 seconds! Creating thread dump
[Paper Watchdog Thread/ERROR]: Server thread dump (Look for plugins here before reporting to Paper!):
```

**A watchdog event is a lag diagnosis, not a crash diagnosis.** Read the thread dump that follows it: the frames show where the main thread was stuck when it stopped responding, and that is your actual problem — a plugin doing something slow, a runaway machine in an automation modpack, or a chunk-generation storm. [Diagnosing Minecraft Server Lag](/knowledge-base/minecraft/diagnosing-lag-and-low-tps/) takes it from there.

> [!CAUTION] Do not "fix" the watchdog by disabling it
> Setting `max-tick-time=-1` turns the watchdog off entirely. It stops the restarts; it does not stop the freezes, and it removes the thread dump that tells you what caused them. Treat it as a last resort while you investigate, not as a solution.

### Everything Else

`Exception in server tick loop`, `Exception ticking world` and `Uncaught exception in server thread` all produce a crash report. Read it exactly as above: `Description:` for the phase, then the first non-vanilla package in the trace. A watchdog kill writes one too, with `Description: Watching Server`.

## Bisection: Finding a Bad Mod or Plugin When the Log Does Not Name One

Sometimes nothing is named — the server dies without a useful trace, or the trace points only at vanilla code. Binary search finds the culprit in a handful of restarts instead of dozens. This is the method PaperMC recommends, and it works identically for `mods/`.

**First, confirm it is a mod or plugin at all.** Rename the whole folder — `plugins` to `plugins-disabled`, or `mods` to `mods-disabled` — and start. If the server comes up, you have your answer. If it does not, stop here: the problem is the server itself, its Java version, or the world.

**Then halve it.** With 32 plugins, five restarts is enough:

| Round | Enabled | Result | Suspect pool |
|---|---|---|---|
| 1 | 16 of 32 | Breaks | Those 16 |
| 2 | 8 of 16 | Fine | The other 8 |
| 3 | 4 of 8 | Breaks | Those 4 |
| 4 | 2 of 4 | Breaks | Those 2 |
| 5 | 1 of 2 | Fine | The other one — found it |

To disable a jar without deleting it, rename `Example.jar` to `Example.jar-disabled`, or move it to a temporary folder outside `plugins/`. The server ignores anything that is not a `.jar`.

Three things that make bisection go wrong:

- **Keep dependency chains together.** Moving Vault out while leaving three plugins that need it produces a new, unrelated failure and wastes a round.
- **Change one thing per restart.** If you also edit a config, you no longer know which change mattered.
- **Take a backup first.** A plugin that stores data may not like being removed and re-added.

Before you start, do the cheap check: make sure every plugin and mod is on a build made for your Minecraft version. Immediately after a version bump, "everything broke" is almost always a stack of plugins that have not been updated yet, not one bad actor.

## What to Capture Before Asking for Help

Send these five and you skip a round trip. Send a screenshot of a screenshot and you will not.

1. **`logs/latest.log` from the failed run**, as a file — not a screenshot, and not the last twenty lines. Upload it to a paste service and send the link if it is large.
2. **The crash report**, if `crash-reports/` gained a file.
3. **Your server type and version** — vanilla, Paper, Purpur, Fabric, Forge or NeoForge, plus the Minecraft version and the Java version on the Startup tab.
4. **What changed.** A mod added, a plugin updated, a version bumped, a config edited. "Nothing" is almost never true; a plugin auto-updater counts.
5. **When it last worked**, and whether it fails on every start or only sometimes.

> [!TIP] Do not restart repeatedly before collecting the log
> Every restart rotates `latest.log` into a `.gz` and starts a fresh one. Three hopeful restarts can push the useful log two files back. Copy it out first, then experiment.

## What to Read Next

- [Minecraft Players Can't Connect](/knowledge-base/minecraft/players-cant-connect/) — for a server that starts fine but rejects joins
- [Diagnosing Minecraft Server Lag](/knowledge-base/minecraft/diagnosing-lag-and-low-tps/) — when the watchdog is firing but nothing crashes
- [Minecraft Server RAM and JVM Flags](/knowledge-base/minecraft/allocating-ram-and-jvm-flags/) — heap sizing, and why more is not always better
- [Updating Your Minecraft Server](/knowledge-base/minecraft/updating-your-server-version/) — Java requirements, world data versions and safe upgrades
- [Minecraft server.properties: The Complete Reference](/knowledge-base/minecraft/server-properties-reference/) — every key named on this page
- [Minecraft World Management](/knowledge-base/minecraft/world-management/) — world files, backups of the world folder, and resets
- [How to create a backup](/knowledge-base/general/how-to-create-a-backup/) — take one before every bisection round
- [How to upload files via SFTP](/knowledge-base/general/how-to-upload-files-via-sftp/) — for pulling logs and crash reports off the server

---

Made with 💜 by GameServerKings