---
title: "Minecraft Server Jar: Official Downloads for Vanilla, Paper, Fabric, Forge and NeoForge"
description: "Where to download every official Minecraft server jar (Mojang, PaperMC, Purpur, Fabric, Forge, NeoForge), how to check it, and what GSK installs for you."
url: "https://www.gameserverkings.com/knowledge-base/minecraft/minecraft-server-jar/"
category: "Minecraft"
category_url: "https://www.gameserverkings.com/knowledge-base/minecraft/"
published: "2026-09-28T04:25:11.247Z"
updated: "2026-09-28T04:25:11.247Z"
source_format: "markdown"
site: "GameServerKings"
---

# Minecraft Server Jar: Official Downloads for Vanilla, Paper, Fabric, Forge and NeoForge

A **Minecraft server jar** is the single Java file that *is* your server: run it with `java -jar` and it generates the world, reads `server.properties` and lets players in. Mojang publishes the vanilla one, and each alternative server (Paper, Purpur, Fabric, Forge, NeoForge) publishes its own through its own download service. This page lists the official download endpoint for each, shows how to check you got the real file, and explains what a GameServerKings server does with the jar so you usually don't have to download one at all.

Everything below was checked against the live endpoints on 27 September 2026, when the newest release was **Minecraft 26.3** (released 15 September 2026).

## Where Each Official Server Jar Comes From

Only download a server jar from the project that builds it. A server jar runs with full access to your machine, so a re-upload on a file-sharing site or a Discord attachment is a real risk, not a shortcut.

| Server | Official source | What you actually get |
|---|---|---|
| **Vanilla** | Mojang's version manifest, `piston-meta.mojang.com/mc/game/version_manifest_v2.json` (the page at minecraft.net/download/server links the current release) | `server.jar`, about 62 MB for 26.3 |
| **Paper** | PaperMC's Fill API, `fill.papermc.io/v3/projects/paper` | `paper-<version>-<build>.jar` |
| **Purpur** | `api.purpurmc.org/v2/purpur` | `purpur-<version>-<build>.jar` |
| **Fabric** | Fabric Meta, `meta.fabricmc.net/v2/versions/...` | A small *launcher* jar (about 180 KB) that fetches Mojang's server on first start |
| **Forge** | `files.minecraftforge.net` and the Forge Maven | An **installer**, not a server jar |
| **NeoForge** | The NeoForged Maven, `maven.neoforged.net/releases/net/neoforged/neoforge/` | An **installer**, not a server jar |
| **Spigot** | Nowhere as a download. You compile it with BuildTools | The jar BuildTools produces |

Which of these you *should* run is a separate question, covered in [Minecraft Server Software Compared](/knowledge-base/minecraft/choosing-server-software/).

### Vanilla: the jar straight from Mojang

The launcher and every hosting tool find the vanilla jar the same way: through Mojang's version manifest. The manifest lists every version, each version has its own JSON file, and that file holds the server download URL, its size and its SHA-1 hash:

```bash title="Fetch the vanilla 26.3 server jar the way the launcher does"
curl -s https://piston-meta.mojang.com/mc/game/version_manifest_v2.json \
  | jq -r '.versions[] | select(.id=="26.3") | .url' \
  | xargs curl -s | jq '.downloads.server, .javaVersion'
```

For 26.3 that returns a URL on `piston-data.mojang.com` ending in `/server.jar`, a size of 62,294,556 bytes, a SHA-1 of `33680f5f2ac32864d6d7cf5e56a705fdb3e05f4c`, and `"majorVersion": 25`. That last value is the Java version the jar needs.

Mojang's download page gives the start command as `java -Xmx4G -Xms4G -jar minecraft_server.<version>.jar nogui`, while the file behind the manifest URL is named `server.jar`. The name doesn't matter, as long as the command uses the name your file actually has.

> [!TIP] Check the hash before you trust the file
> `shasum server.jar` on macOS or Linux, or `Get-FileHash server.jar -Algorithm SHA1` in PowerShell, should print exactly the `sha1` from the version JSON. If it doesn't, the file is truncated or isn't Mojang's.

Snapshots and pre-releases sit in the same manifest with `"type": "snapshot"`. The newest on 27 September was `26.4-snapshot-1`. Running one safely is covered in [How to Run a Minecraft Snapshot Server](/knowledge-base/minecraft/running-a-snapshot-server/).

### Paper and Purpur

Paper's Fill API lists builds per version. Each build carries a **channel** and a `server:default` download with a SHA-256 checksum:

```bash title="List the newest Paper builds for a version"
curl -s -H "User-Agent: my-server-setup (you@example.com)" \
  https://fill.papermc.io/v3/projects/paper/versions/26.2/builds \
  | jq -r '.[0:3][] | "\(.id)  \(.channel)  \(.downloads."server:default".url)"'
```

The channel is worth checking. On 27 September, **all 48 Paper builds for 26.3 were marked `ALPHA`**, while 26.2 had 43 `STABLE` builds. A brand-new Minecraft version usually spends a while in alpha on Paper, so if stability matters more than being first, run the previous version until a stable build appears. PaperMC's documentation says every request must send a `User-Agent` that identifies you and isn't generic, as in the example.

Purpur's API is simpler: `https://api.purpurmc.org/v2/purpur/26.3/latest/download` returns the newest build for 26.3 (build 2642 on the day we checked).

### Fabric

Fabric Meta builds a server launcher to order from three numbers: the Minecraft version, the Fabric Loader version and the installer version:

```text title="Fabric server launcher for 26.3"
https://meta.fabricmc.net/v2/versions/loader/26.3/0.19.5/1.1.2/server/jar
```

That downloads `fabric-server-mc.26.3-loader.0.19.5-launcher.1.1.2.jar`. It's tiny because it isn't the game. On first start it downloads Mojang's own server jar into a `.fabric` folder and loads it with Fabric. The first boot takes longer, and `.fabric/` isn't clutter. [Fabric Mods on a Server](/knowledge-base/minecraft/fabric-server-setup/) covers the rest.

### Forge and NeoForge: there is no single server jar

This is why people searching for a "Forge server jar" come up empty. Modern Forge and NeoForge ship an **installer**. You run `java -jar <installer>.jar --installServer` and it builds a `libraries/` folder plus a launch script. The server then starts from an arguments file (`unix_args.txt` on Linux) rather than from one jar.

- **Forge:** `promotions_slim.json` on files.minecraftforge.net names the recommended and latest build for each Minecraft version. For 26.3 there was a *latest* (66.0.6) but no *recommended* build yet.
- **NeoForge:** the Maven's `maven-metadata.xml` lists every build. NeoForge version numbers drop the leading `1.` of older Minecraft versions: Minecraft 1.21.1 is NeoForge `21.1.x`, and Minecraft 26.3 is `26.3.0.x`. Every 26.3 build was still tagged `-beta` on the day we checked.

Modpacks normally bring their own server files, so for a pack, follow [How to Make a Modded Minecraft Server](/knowledge-base/minecraft/installing-modpacks/) rather than fetching Forge yourself.

### Spigot

Spigot has no official server jar download. SpigotMC publishes **BuildTools** (from `hub.spigotmc.org/jenkins/job/BuildTools/`), and you compile the server yourself with `java -jar BuildTools.jar --rev 26.3`. A ready-made `spigot-26.3.jar` on a download site didn't come from SpigotMC.

## How a GameServerKings Server Gets Its Jar

You don't need to download anything to run one of the frameworks above on GSK. The Minecraft (Java) server's installer fetches the jar from the same official endpoints listed in the table. You pick what you want on the **Startup** tab:

| Startup variable | What it does |
|---|---|
| **Framework** | `VANILLA`, `PAPER` (default), `PURPUR`, `SPIGOT`, `FABRIC`, `FORGE` or `NEOFORGE` |
| **Minecraft Version** | `latest`, or a version such as `26.2` |
| **Build Number** | `latest`, or a specific Paper/Purpur build |
| **Server Jar File** | The filename the jar is saved as and launched from. Default `server.jar` |
| **Accept Mojang EULA** | Writes `eula=true` to `eula.txt` for you |

After changing any of these, run **Reinstall Server** from the **Settings** tab. The installer then works like this:

1. It removes the previous framework's files: the jar named in **Server Jar File**, `unix_args.txt`, Forge/NeoForge libraries and `.fabric/`. Your worlds, `server.properties`, `plugins/` and `mods/` are kept.
2. It downloads the matching jar: the vanilla jar from Mojang's manifest, the newest **stable** Paper build (falling back to the newest build of any channel if a version has no stable build yet), the newest Purpur build, a Fabric launcher using the newest stable loader, or it runs the Forge/NeoForge installer. Spigot is compiled with BuildTools, which takes 5 to 10 minutes.
3. For Forge and NeoForge it copies `unix_args.txt` into the server root. The start command checks for that file first and launches from it instead of `-jar server.jar`.
4. It prints the Java version Mojang lists for your Minecraft version, for example `Minecraft 26.3 expects Java 25`. Match the **Docker Image** on the Startup tab to it. Java 8, 11, 16, 17, 21, 22 and 25 are available.

> [!NOTE] "latest" is today's latest, at install time
> `latest` is resolved when the installer runs, not every time the server starts. The server stays on that version until you reinstall. With **Framework** `PAPER` and **Minecraft Version** `latest`, an install on 27 September resolves to 26.3, where every Paper build is still alpha, so you get an alpha build. Put `26.2` in **Minecraft Version** if you want a stable Paper build today.

> [!WARNING] NeoForge 1.21.1 on the current installer
> NeoForge builds for Minecraft 1.21.1 are numbered `21.1.x`, and builds for 1.21.10 and 1.21.11 are `21.10.x` and `21.11.x`. If you set **Minecraft Version** to `1.21.1` with **NEOFORGE**, check the install log for the NeoForge version it picked. If it starts with `21.11`, you got a 1.21.11 build. Open a ticket and we'll install the correct 1.21.1 build. Modpack server files, which bring their own NeoForge version, aren't affected.

### Running a jar the installer doesn't offer

If you want a jar that isn't in the **Framework** list (a Paper fork, a specific old build, something you compiled), upload it to the server root and set **Server Jar File** to its exact filename. A reinstall deletes the file that variable names, so keep a copy. The full procedure, and what will and won't run that way, is in [How to Run a Custom Server JAR](/knowledge-base/minecraft/install-a-custom-jar/).

## When the Jar Won't Start

| Console output | Meaning |
|---|---|
| `Error: Unable to access jarfile server.jar` | The file named in **Server Jar File** isn't in the server root. See [Unable to access jarfile](/knowledge-base/minecraft/error-unable-to-access-jar-file/) |
| `UnsupportedClassVersionError ... class file version 69.0` | The jar needs Java 25 and an older image is selected. Change the Docker Image |
| `no main manifest attribute` | You uploaded an installer, plugin or library jar, not a server jar |
| The server asks you to agree to the EULA and stops | `eula.txt` still says `false`. Set **Accept Mojang EULA** to `true` or edit the file |

Anything after the first few lines is a crash rather than a jar problem. [Reading Minecraft Server Logs and Crash Reports](/knowledge-base/minecraft/reading-crash-logs-and-common-errors/) covers those.

## FAQ

**Is the Minecraft server jar free?**
Yes. Mojang's server download is free. Mojang's download page says that downloading it means you agree to the Minecraft End User License Agreement, which is what `eula.txt` records.

**Can I use a server jar for Bedrock?**
No. Bedrock Dedicated Server isn't a Java jar and Bedrock players can't join a Java server directly. See [Setting up your Bedrock Minecraft server](/knowledge-base/minecraft/bedrock/), or [cross-play with Geyser](/knowledge-base/minecraft/geyser-crossplay/).

**Where do old versions come from?**
The same places. Mojang's manifest still lists every release back to 1.0 (2011), and Paper's API goes back to 1.7.10. On GSK, put the version in **Minecraft Version** and reinstall. Moving a world *down* a version is not supported, so take a backup first. [Updating Your Minecraft Server](/knowledge-base/minecraft/updating-your-server-version/) covers the details.

**How much RAM does the jar need?**
Mojang's example command uses 4 GB. On GSK the heap is sized from your plan automatically; [Minecraft Server RAM and JVM Flags](/knowledge-base/minecraft/allocating-ram-and-jvm-flags/) explains how.

## What to Read Next

- [Minecraft Server Software Compared](/knowledge-base/minecraft/choosing-server-software/): which framework to choose
- [How to Run a Custom Server JAR](/knowledge-base/minecraft/install-a-custom-jar/): jars the installer doesn't offer
- [Updating Your Minecraft Server](/knowledge-base/minecraft/updating-your-server-version/): versions, Java 25 and safe upgrades
- [Fabric Mods on a Server](/knowledge-base/minecraft/fabric-server-setup/): the Fabric launcher in detail
- [How to Make a Modded Minecraft Server](/knowledge-base/minecraft/installing-modpacks/): Forge, NeoForge and modpack server files

---

Made with 💜 by GameServerKings
