---
title: "How to Run a Minecraft Snapshot Server and Test the Next Version Safely"
description: "Which frameworks can run a snapshot, how to set the version, and why a snapshot world is a one-way door you must never point at your live save."
url: "https://www.gameserverkings.com/knowledge-base/minecraft/running-a-snapshot-server/"
category: "Minecraft"
category_url: "https://www.gameserverkings.com/knowledge-base/minecraft/"
published: "2026-08-19T10:11:56.542Z"
updated: "2026-08-19T10:20:09.179Z"
source_format: "markdown"
site: "GameServerKings"
---

# How to Run a Minecraft Snapshot Server and Test the Next Version Safely

Snapshots are Mojang's weekly builds of the next Minecraft release. Mojang publishes a runnable `server.jar` for every one of them, so a snapshot server is entirely possible — and the reason to run one is narrow but real: finding out what the next release will do to your world, your configs and your plugin set *before* it lands.

What makes this worth writing down is that a snapshot server has one property no other Minecraft server has. **A world it touches can never go back.** Everything below is arranged around that fact.

## Where the Version Numbers Come From

Mojang's version manifest is the authoritative list, and it is a plain JSON file you can read yourself:

```text title="The version manifest"
https://launchermeta.mojang.com/mc/game/version_manifest_v2.json
```

Its `latest` object names the current release and the current snapshot. **Checked on 19 August 2026** it reads:

```json title="version_manifest_v2.json → latest"
{
  "release": "26.2",
  "snapshot": "26.3-snapshot-9"
}
```

26.2 was released on 16 June 2026; `26.3-snapshot-9` was published on 17 August 2026. Since the December 2025 numbering change, snapshots are named `<Version> Snapshot <N>` — the snapshot's own metadata calls itself `26.3 Snapshot 9` — and the manifest renders that as the id `26.3-snapshot-9`. The old `25w44a` week-number style is retired except for Mojang's annual April Fools build. [Updating Your Minecraft Server](/knowledge-base/minecraft/updating-your-server-version/) covers the numbering change in full.

Pre-releases and release candidates use the same list, as `26.2-pre-1` and `26.2-rc-1`. All three kinds carry a server download in their metadata, so all three are runnable.

## Which Frameworks Can Actually Run One

This is the part that decides your plan, and it is not the same answer for every framework.

| Framework | Can it run `26.3-snapshot-9`? | Why |
|---|---|---|
| **Vanilla** | Yes | Mojang publishes a server jar for every snapshot |
| **Fabric** | Yes | Fabric's metadata tracks snapshot game versions and serves a matching loader |
| **Paper** | No | Paper builds for releases and release candidates, not weekly snapshots |
| **Purpur** | No | Built on Paper |
| **Spigot** | No | BuildTools targets release revisions |
| **Forge** | No | Builds follow releases |
| **NeoForge** | No | Builds follow releases |

Checked live on 19 August 2026: Fabric's metadata lists `26.3-snapshot-9` as a non-stable game version and returns a loader build for it, while Paper's build API lists `26.2` and `26.2-rc-2` under the 26.2 line and nothing at all for 26.3.

The practical consequence is blunt. **A snapshot server means no plugins.** Bukkit-family plugins are compiled against a release API and there is no Paper to load them into. If your server's identity is its plugin set, a snapshot test tells you very little — and Fabric with a handful of server mods is the closer analogue.

## Setting It Up

Use a **separate server**, not your live one. Then:

1. Set **Framework** to `VANILLA` (or `FABRIC` if you want mods).
2. Set **Minecraft Version** to the exact manifest id — `26.3-snapshot-9`, not `26.3`, not `latest`.
3. Leave **Build Number** at `latest`. It is only consulted by the frameworks that have their own build numbering.
4. Reinstall from the **Settings** tab.

The installer looks the id up in the manifest and downloads the server jar Mojang published for it. If you mistype it you get an unambiguous failure rather than a silent fallback:

```text title="Console output"
!! Unknown Minecraft version: 26.3-snapshot-09
```

> [!IMPORTANT] `latest` never means a snapshot
> The **Minecraft Version** variable resolves `latest` to the manifest's `latest.release`, which is 26.2 today. It will never select a snapshot for you. If you want one you must name it, and that is deliberate — nobody should get a snapshot by accident.

**Java 25.** Every 26.x build, snapshot or release, declares `"javaVersion": 25` in its metadata. If the server exits with `UnsupportedClassVersionError`, set the Java 25 image on the **Startup** tab; [Reading Minecraft Server Logs and Crash Reports](/knowledge-base/minecraft/reading-crash-logs-and-common-errors/) has the class-file-version table.

## The One-Way Door

Here is what actually separates a snapshot server from an ordinary one.

Every Minecraft build stamps a **world data version** into the save. The numbers are not the Minecraft version and they only ever go up:

| Build | World data version | Data pack format | Protocol |
|---|---|---|---|
| 1.21.11 | 4671 | 94.1 | 774 |
| 26.2 (current release) | 4903 | 107.1 | 776 |
| 26.3-snapshot-9 | 5011 | 117.0 | 1073742155 |

When a snapshot opens a world written by 26.2, it **upgrades the save in place** to its own data version. There is no prompt on a dedicated server and no undo. Point 26.2 at that world afterwards and the server refuses:

```text title="Console output"
This world was created by an incompatible version.
```

That line is logged at **INFO**, not ERROR, and the server then exits without a stack trace or a crash report. If you are scanning a log for the word `ERROR` you will scroll straight past the only line that explains the shutdown.

Paper additionally guards at chunk level, with a message vanilla does not have:

```text title="Console output"
java.lang.RuntimeException: Server attempted to load chunk saved with newer version of minecraft! 5011 > 4903
```

**Minecraft does not support downgrading a world.** Not with a flag, not with a tool, not by editing `level.dat`. The only route back is a backup taken before the snapshot ever started.

> [!CAUTION] Never point a snapshot at your live world
> Copy it. Copy it to a different server, not a different folder on the same one — a mistyped `level-name` on a shared machine is exactly how this goes wrong. [Minecraft World Management](/knowledge-base/minecraft/world-management/) covers moving a world properly, and [How to create a backup](/knowledge-base/general/how-to-create-a-backup/) covers taking the backup first.

Two further consequences of that table:

- **The data pack format jumped from 107 to 117.** Every datapack you run declares a `pack_format`, and one built for 26.2 will be refused or warned about by 26.3. So will resource packs, on their own separate number. [How to Install Datapacks and Resource Packs](/knowledge-base/minecraft/datapacks-and-resource-packs/) covers the field.
- **The protocol version is not a small increment.** Snapshots set a high bit — `1073742155` is 2³⁰ plus 331 — which guarantees that no release client can ever negotiate with a snapshot server by accident. Players must switch their launcher profile to the exact snapshot, and the mismatch message is the ordinary one from [Minecraft Players Can't Connect](/knowledge-base/minecraft/players-cant-connect/).

## A Test That Is Worth Running

The point is not to be first. It is to find out what breaks while there is still time to say something about it.

1. **Take a backup of the live world**, and verify it restores. Everything after this assumes you can throw the test away.
2. **Copy the world to a separate server** and set that server to the snapshot.
3. **Copy your configs too** — `server.properties`, and your world settings. Config keys are added and removed between versions, and a key that has been removed is a silent behaviour change rather than an error.
4. **Start it and read the whole log**, not just the end. Datapack warnings, removed `server.properties` keys and world-upgrade messages all appear during the first boot and never again.
5. **Walk the things your community depends on.** Farms, redstone, mob spawners, any automation. This is what a snapshot test is actually for.
6. **Throw it away.** The snapshot world is disposable by design — snapshot worlds can break between one snapshot and the next, not only between releases.

## When to Use a Pre-Release Instead

If your server runs Paper and your plugin set matters, weekly snapshots are the wrong tool. Wait for the **release candidate**: Paper builds for those, so an RC test exercises your real framework and most of your real plugins. On 19 August 2026 Paper's build list carried `26.2-rc-2` alongside `26.2`, and nothing for the 26.3 snapshots — which is the whole difference in one line.

The sequence Mojang runs is snapshots, then `-pre-N`, then `-rc-N`, then the release. The later you test, the more of your stack you can test with; the earlier you test, the more time there is for anything you report to be fixed.

## What to Read Next

- [Updating Your Minecraft Server](/knowledge-base/minecraft/updating-your-server-version/) — the 2026 numbering change, Java requirements and safe upgrades
- [Minecraft Server Software Compared](/knowledge-base/minecraft/choosing-server-software/) — which framework tracks which Minecraft version
- [Minecraft World Management](/knowledge-base/minecraft/world-management/) — copying, moving and resetting worlds
- [How to create a backup](/knowledge-base/general/how-to-create-a-backup/) — the step that makes a snapshot test reversible
- [Reading Minecraft Server Logs and Crash Reports](/knowledge-base/minecraft/reading-crash-logs-and-common-errors/) — Java versions, world data versions and world-load failures
- [Minecraft Players Can't Connect](/knowledge-base/minecraft/players-cant-connect/) — the version-mismatch messages your testers will see
- [How to Install Datapacks and Resource Packs on a Minecraft Server](/knowledge-base/minecraft/datapacks-and-resource-packs/) — pack formats across a version jump
- [Minecraft Server Won't Start](/knowledge-base/minecraft/why-wont-my-server-start/) — if the snapshot server does not come up at all

---

Made with 💜 by GameServerKings