# AGENTS
Source: https://docs.purpify.host/AGENTS
# Purpify documentation instructions
## About this project
* This Mintlify site documents Purpify Minecraft hosting.
* Purpify supports Minecraft Java Edition, native Bedrock Edition, modded servers, and Geyser cross-play.
* The game panel is at `panel.purpify.host`.
* The billing portal is at `payments.purpify.host`.
* Pages are MDX files with YAML frontmatter. Navigation lives in `docs.json`.
* Run `mint dev` to preview locally.
* Run `mint broken-links`, `mint a11y`, and `mint validate` before publishing.
## Information architecture
* **Get started**: edition choice, first server, shared reference, and help.
* **Panel**: server creation, controls, console, files, SFTP, backups, and panel troubleshooting.
* **Java Edition**: connection, server software, plugins, mods, modpacks, and Geyser.
* **Bedrock Edition**: connection, Bedrock worlds, behavior packs, resource packs, and Bedrock troubleshooting.
* **Billing**: services, invoices, payments, renewals, cancellations, and policy links.
Put a topic in one canonical section. Cross-link it instead of duplicating the same procedure.
## Audience and outcomes
* Write for server owners who may never have managed a game server.
* Help readers complete one task or diagnose one symptom per page.
* State prerequisites, edition, server software, and consequences before steps.
* Identify whether instructions apply to Java, Bedrock, or Geyser.
## Terminology
* Use "Purpify game panel" or "game panel" for `panel.purpify.host`.
* Use "billing portal" for `payments.purpify.host`.
* Use "server" for a hosted game-server instance.
* Use "Minecraft Java Edition" or "Minecraft Bedrock Edition" on first mention.
* Use "plugin" only for Java server plugins.
* Use "mod" and "modpack" only for Java mod-loader content.
* Use "add-on" for Bedrock behavior packs and resource packs.
* Describe Geyser as Bedrock-to-Java cross-play, not as a native Bedrock server.
* Use "server address" and "server port" as separate values.
## Style
* Use active voice and second person ("you").
* Keep sentences concise and headings in sentence case.
* Lead with the answer before background information.
* Bold exact UI labels: Select **New Server**.
* Use code formatting for files, commands, paths, settings, and exact values.
* Define technical terms on first use.
* Use specific nouns instead of ambiguous pronouns.
* Add descriptive frontmatter, keywords, cross-links, and image alt text.
## Draft frames
* Use `noindex: "true"` while a page contains unverified TODO sections.
* Remove `noindex` only after the content is accurate enough for search and AI answers.
* Mark unknown details with `{/* TODO: Verify the value or workflow. */}`.
## Accuracy and content boundaries
* Never invent panel labels, URLs, ports, file limits, plan limits, defaults, supported versions, retention periods, or time estimates.
* Link policy questions to the current Purpify policy instead of paraphrasing unverified terms.
* Never publish passwords, tokens, private server addresses, invoices, or personal player data.
* Do not mix Java plugins, Java mods, Bedrock add-ons, and Geyser extensions.
# Enable Beta APIs
Source: https://docs.purpify.host/bedrock/beta-apis
Enable the Beta APIs experiment for a Purpify Minecraft Bedrock Edition world through World Manager or level.dat.
Enable **Beta APIs** only when a Bedrock add-on requires experimental script APIs. You can use **World Manager** or edit the active world's `level.dat` file.
## Before you begin
* Confirm that this is a native Minecraft Bedrock Edition server.
* Check that the add-on specifically requires the **Beta APIs** experiment.
* Stop the server before changing the world.
* Create a [server backup](/server/backups).
* Identify the active world before using the file method.
Beta APIs can change or be removed in later Minecraft versions. After you enable an experiment for a world, you cannot return that world to a non-experimental state. Keep an untouched backup.
## Choose a method
Open the server in the Purpify game panel, then go to **World Manager**.
Find the world currently used by the server and select **Edit**.
Go to **Experiments**, then enable **Beta APIs**.
Save the world settings, restart the server, and watch the console for add-on or scripting errors.
Open the file manager and go to `worlds/`, replacing `` with the folder used by the server.
Select `level.dat` to open the world-data editor.
Find the **Experiments** section and enable **Beta APIs**. Save the file.
Restart the server and watch the console. Confirm that the add-on loads without a missing experiment or unsupported API error.
Use World Manager when possible. The `level.dat` method is useful when you need to edit the active world directly.
## If Beta APIs does not work
* Confirm that you edited the active world rather than another folder in `worlds`.
* Stop the server before saving `level.dat`, then restart it after the change.
* Confirm that **Beta APIs** remains enabled after reopening the world settings.
* Check the add-on's `manifest.json` and installation instructions for its required Minecraft and script API versions.
* Restore the backup if the world or add-on stops loading correctly.
Install the behavior and resource packs that use the experiment.
Learn how to edit and protect server files.
# Change the Bedrock server difficulty
Source: https://docs.purpify.host/bedrock/change-difficulty
Set a Purpify Minecraft Bedrock Edition server to Peaceful, Easy, Normal, or Hard.
Set the difficulty to `peaceful`, `easy`, `normal`, or `hard`. You can use the console, an in-game command, or `server.properties`.
| Difficulty | Effect |
| ---------- | ----------------------------------------------------------------- |
| `peaceful` | Removes the normal hostile-mob survival threat. |
| `easy` | Uses reduced hostile-mob damage and an easier survival challenge. |
| `normal` | Uses the standard survival difficulty. |
| `hard` | Uses stronger hostile-mob damage and a harder survival challenge. |
## Change difficulty with a command
Start the server, open its console view, and enter `difficulty` without a leading `/`.
```text theme={"dark"}
difficulty normal
```
Join as an [operator](/bedrock/operators), open chat, and enter the command with a leading `/`.
```text theme={"dark"}
/difficulty normal
```
Replace `normal` with `peaceful`, `easy`, or `hard` when needed.
## Change difficulty in server.properties
Stop the server before editing its configuration.
Open the file manager and select `server.properties`.
Set `difficulty` to one supported value.
```properties theme={"dark"}
difficulty=normal
```
Save the file, start the server, and join to confirm the new difficulty.
Review other settings stored in `server.properties`.
# Connect to a Bedrock server
Source: https://docs.purpify.host/bedrock/connect
Add a Purpify Minecraft Bedrock Edition server with its server address and port.
Add your Purpify server as an external server in Minecraft Bedrock Edition. You need the server address and port shown in the Purpify panel.
## Before you connect
* Start the server and wait until the panel shows it as running.
* Use a Minecraft version that is compatible with the server.
* Copy the current address and port from the server management view.
* Confirm that your device shows an **Add Server** option. If it does not, use TransferBot instead.
## Add the server
Open your server in the Purpify panel. Copy its address and port from the server management view.
In Minecraft Bedrock Edition, select **Play** > **Servers** > **Add Server** on a supported device.
Enter any name in **Server Name**. Paste the Purpify address into **Server Address**, then enter the Purpify port in **Port**.
Save the server entry and select it to connect. If Minecraft cannot connect, recopy both values from the panel and try again.
## Connect with TransferBot
TransferBot is an optional connection method for friends or devices that cannot add an external server directly. Add a TransferBot for your Purpify server, then follow the video tutorial to connect.
Follow Purpify's video guide to configure and use TransferBot.
## Connection errors
Follow [Troubleshoot connection problems](/troubleshooting/cannot-connect) if the server appears offline or Minecraft cannot connect.
Browse the main Bedrock Edition guides.
Move a Bedrock world to your Purpify server.
# Enable cheats on a Bedrock server
Source: https://docs.purpify.host/bedrock/enable-cheats
Enable cheat commands on a Purpify Minecraft Bedrock Edition server through server.properties.
Set `allow-cheats=true` in `server.properties`, then restart the server. This setting allows commands that require cheats on a native Minecraft Bedrock Edition server.
## Enable cheats
Stop the server before editing `server.properties` so the running process does not overwrite the change.
Open the file manager and select `server.properties` in the server's main directory.
Find `allow-cheats` and set its value to `true`.
```properties theme={"dark"}
allow-cheats=true
```
Save the file, start the server, and watch the console for startup errors.
To disable cheats later, set `allow-cheats=false`, save the file, and restart the server.
Cheats allow authorized players to run commands that can change the world, player data, and server behavior. Grant [operator access](/bedrock/operators) only to people you trust.
Change world mechanics after enabling cheats.
Review other Bedrock server settings.
# Set game rules on a Bedrock server
Source: https://docs.purpify.host/bedrock/game-rules
Change Minecraft Bedrock Edition game rules through the Purpify console or in-game chat.
Use the `gamerule` command to change how the active Bedrock world behaves. Game rule names are case-sensitive.
## Before you begin
* Start the server and wait until the world finishes loading.
* [Enable cheats](/bedrock/enable-cheats) before changing game rules in Minecraft chat.
* Join as an [operator](/bedrock/operators) when using the in-game method.
* Create a [backup](/server/backups) before changing rules that could affect builds or player data.
## Set a game rule
Open the server console and enter the command without a leading `/`.
```text theme={"dark"}
gamerule keepinventory true
```
Open chat and enter the command with a leading `/`.
```text theme={"dark"}
/gamerule keepinventory true
```
Use this format for another rule:
```text theme={"dark"}
gamerule
```
## Common Bedrock game rules
| Rule | Value | What it controls |
| --------------------------- | ----------------- | ---------------------------------------------------------- |
| `keepinventory` | `true` or `false` | Whether players keep inventory and experience after death. |
| `showcoordinates` | `true` or `false` | Whether coordinates appear on the player HUD. |
| `mobgriefing` | `true` or `false` | Whether mobs can change blocks or pick up items. |
| `domobspawning` | `true` or `false` | Whether mobs spawn naturally. |
| `domobloot` | `true` or `false` | Whether mobs drop items and experience. |
| `dodaylightcycle` | `true` or `false` | Whether time and moon phases advance. |
| `doweathercycle` | `true` or `false` | Whether weather changes naturally. |
| `playerssleepingpercentage` | Percentage | How many Overworld players must sleep to skip the night. |
| `pvp` | `true` or `false` | Whether players can damage other players. |
| `randomtickspeed` | Number | How frequently random block ticks occur. |
| `tntexplodes` | `true` or `false` | Whether activated TNT explodes. |
| `commandblocksenabled` | `true` or `false` | Whether command blocks can run. |
## Check a game rule
Enter the rule without a value to display its current setting.
```text theme={"dark"}
gamerule keepinventory
```
Learn how to enter commands and inspect console output.
# Kick a Bedrock player
Source: https://docs.purpify.host/bedrock/kick-player
Disconnect a player from a native Minecraft Bedrock Edition server with the kick command.
Use the `kick` command to disconnect a player from a native Minecraft Bedrock Edition server. Kicking a player does not permanently block that player.
## Before you begin
* Start the server and wait until it finishes loading.
* Confirm that the player is connected.
* Use the player's exact Xbox Gamertag, including spaces and capitalization.
* Put a Gamertag in quotation marks when it contains spaces, such as `"Example Player"`.
## Kick a player
Open the server in the Purpify game panel, then open its console view.
Find the player's exact Xbox Gamertag in the console.
Enter `kick`, the player's Gamertag, and an optional reason. Do not add a leading `/` in the console.
```text theme={"dark"}
kick "Example Player" "Please contact the server owner."
```
Check the console for the disconnect message.
## Prevent the player from reconnecting
Kicking only ends the current connection. To prevent the player from reconnecting, [enable the allowlist and remove the player's Gamertag](/bedrock/whitelist).
For Bedrock players joining through Geyser, use the Java server's player-management tools instead of this native Bedrock command.
# Manage Bedrock players
Source: https://docs.purpify.host/bedrock/manage-players
Whitelist, kick, and grant operator access to players on a native Minecraft Bedrock Edition server.
Use the Purpify game panel console to manage players on a native Minecraft Bedrock Edition server. Enter console commands without a leading `/`.
For Bedrock players joining through Geyser, follow the Java server's player-management and permission procedures instead.
Restrict your server to approved Xbox Gamertags.
Grant or remove administrative command access.
Disconnect a player from the server.
Learn how to enter commands and review console output.
# Manage Bedrock operators
Source: https://docs.purpify.host/bedrock/operators
Grant or remove operator access on a native Minecraft Bedrock Edition server.
Grant operator access to let a player run administrative commands on a native Minecraft Bedrock Edition server.
Operators can run commands that make major changes to the server and world. Grant operator access only to people you trust.
## Before you begin
* Start the server and wait until it finishes loading.
* Ask the player to join. The `op` command does not work for an offline player.
* Use the player's exact Xbox Gamertag, including spaces and capitalization.
* Put a Gamertag in quotation marks when it contains spaces, such as `"Example Player"`.
* Confirm that this is a native Bedrock server. For Bedrock players joining through Geyser, use the Java server's permission system.
## Grant operator access
Open the server in the Purpify game panel, then open its console view.
Wait until the player's exact Xbox Gamertag appears in the console.
Enter `op` followed by the player's exact Xbox Gamertag. Do not add a leading `/` in the console.
```text theme={"dark"}
op "Example Player"
```
Ask the player to reconnect if the permission does not take effect immediately. The player can test a harmless command such as `/list` in Minecraft chat.
## Remove operator access
Run `deop` followed by the player's exact Xbox Gamertag:
```text theme={"dark"}
deop "Example Player"
```
An existing operator can run the same commands in Minecraft chat by adding a leading `/`.
## Fix common problems
Confirm that the player is connected, then re-enter the exact Xbox Gamertag. Put the full Gamertag in quotation marks if it contains spaces.
Confirm that the server is running native Minecraft Bedrock Edition. Enter commands without `/` in the game panel console and with `/` in Minecraft chat.
Geyser provides Bedrock-to-Java cross-play. Manage the player with the Java server's operator or plugin permission system instead.
# Minecraft Bedrock Edition
Source: https://docs.purpify.host/bedrock/overview
Set up and customize a native Purpify Minecraft Bedrock Edition server.
Choose Bedrock Edition for a native Bedrock server with Bedrock worlds, behavior packs, and resource packs.
Open game panel
## Bedrock guides
Add the server address and port in Minecraft Bedrock Edition.
Grant operator access, use the allowlist, and remove players.
Allow commands that require cheats on the Bedrock server.
Choose Peaceful, Easy, Normal, or Hard.
Change world behavior with Bedrock game rules.
Configure gameplay, players, networking, and scripting.
Move an existing Bedrock world to Purpify.
Generate a fresh world without resetting the complete server.
Install behavior packs and resource packs.
Enable experimental scripting APIs for an add-on that requires them.
Erase the current installation and start again.
Check status, version, address, port, and device support.
Separate server, network, and client performance problems.
Check packs, dependencies, experiments, and script errors.
This section covers native Bedrock servers. To let Bedrock players join a Java server, use [Geyser cross-play](/java/geyser).
# Completely reset a Bedrock server
Source: https://docs.purpify.host/bedrock/reset-server
Erase a Purpify Minecraft Bedrock Edition server installation and start again from the game panel.
Use **Reset** in the server's **Settings** to erase the current installation and return the Bedrock server to a fresh state.
A complete reset removes the current world, player data, add-ons, and configuration from the server. Download anything you want to keep before continuing.
## Before you reset
* Confirm that you selected the correct Purpify server.
* Download the current world and any configuration or add-on files you want to retain.
* Create a [server backup](/server/backups) and keep an external copy of important data.
* Tell connected players that the server will be reset.
## Reset the server
Stop the server and wait until the console confirms that the process has ended.
Open the server in the Purpify game panel and go to **Settings**.
Find the reset section and select **Reset**.
Read the displayed reset warning and confirm only if you no longer need the current server data.
Wait for the reset to finish, then start the server. Watch the console and confirm that a new Bedrock world loads.
If you only want a different world, follow [Upload an existing world](/server/upload-world) instead of resetting the complete server.
Protect the current server before a destructive change.
Diagnose startup errors after setting up the fresh server.
# Reset a Bedrock world
Source: https://docs.purpify.host/bedrock/reset-world
Generate a fresh Minecraft Bedrock Edition world on Purpify without resetting the complete server installation.
Reset only the active world when you want fresh terrain but want to keep the server installation and its other configuration. The safest method is to give the new world a different `level-name`.
Resetting or deleting a world removes its builds, inventories, player locations, and world-specific data from active use. Download an external copy before continuing.
## Create a fresh world with a new name
Create a [backup](/server/backups), download the current world if you need an external copy, then stop the server.
Open the file manager and select `server.properties`.
Change `level-name` to a folder name that does not already exist in `worlds`.
```properties theme={"dark"}
level-name=Fresh Bedrock World
```
Save the file and start the server. Bedrock creates a new world using the new folder name.
Join the server and confirm that fresh terrain loaded. Keep the old world folder until you know the new world works.
## Delete and regenerate the selected world
Use this method only when you no longer need the current world folder.
Open `server.properties` and note the exact `level-name` value.
Stop the server and download the matching folder from `worlds` if you may need it later.
Open `worlds`, select the folder matching `level-name`, and delete it. Do not delete a different world.
Start the server. Bedrock generates a new world under the configured `level-name`.
To erase the world, add-ons, configuration, and complete installation together, follow [Completely reset a Bedrock server](/bedrock/reset-server).
Replace the active world with one you already have.
Review the settings stored in `server.properties`.
# Minecraft Bedrock server properties
Source: https://docs.purpify.host/bedrock/server-properties
Edit common Minecraft Bedrock Edition settings in server.properties on a Purpify server.
The `server.properties` file controls gameplay, access, networking, performance, and scripting settings for a native Minecraft Bedrock Edition server.
## Edit server.properties
Create a [server backup](/server/backups) before changing several settings or an unfamiliar advanced property.
Stop the server so it does not overwrite the file while you edit it.
Open the file manager and select `server.properties` in the server's main directory.
Keep one property per line in `name=value` format. Use an accepted value and do not add spaces around `=`.
```properties theme={"dark"}
difficulty=normal
```
Save the file, start the server, and watch the console for an invalid-value or configuration error.
Do not change `server-port`, `server-portv6`, or other network fields unless Purpify instructs you to. The server must use its assigned network allocation.
## Gameplay and world properties
| Property | Accepted value or purpose |
| ---------------------- | ------------------------------------------------------------------------------- |
| `allow-cheats` | `true` or `false`; allows commands that require cheats. |
| `difficulty` | `peaceful`, `easy`, `normal`, or `hard`. |
| `gamemode` | `survival`, `creative`, or `adventure` for new players. |
| `force-gamemode` | `true` forces the configured game mode instead of the world's saved mode. |
| `level-name` | Selects the world folder used by the server. |
| `level-seed` | Sets the seed used when generating a world. |
| `tick-distance` | Controls how many nearby chunks continue ticking. Supported range: `4` to `12`. |
| `view-distance` | Limits the number of chunks sent around each player. |
| `texturepack-required` | `true` requires players to accept the server resource pack. |
## Player and access properties
| Property | Accepted value or purpose |
| --------------------------------- | ------------------------------------------------------------------------------ |
| `allow-list` | `true` restricts connections to players in `allowlist.json`. |
| `default-player-permission-level` | `visitor`, `member`, or `operator`. |
| `max-players` | A positive number limiting simultaneous players. |
| `online-mode` | Controls Xbox Live authentication; keep enabled for an internet-facing server. |
| `player-idle-timeout` | Minutes before an idle player is removed; `0` disables the timeout. |
| `chat-restriction` | `None`, `Dropped`, or `Disabled`. |
| `disable-custom-skins` | `true` blocks skins created outside Minecraft's provided assets. |
| `disable-player-interaction` | `true` tells clients to ignore interactions involving other players. |
## Performance and networking properties
| Property | Accepted value or purpose |
| ------------------------------------------------- | ------------------------------------------------------------------------------- |
| `server-name` | The name advertised by the Bedrock server; do not use a semicolon. |
| `max-threads` | Maximum server threads; `0` allows all available threads. |
| `compression-algorithm` | `zlib` or `snappy`. |
| `compression-threshold` | Payload size at which network compression begins. |
| `enable-lan-visibility` | Controls whether the server responds to LAN discovery. |
| `client-side-chunk-generation-enabled` | Allows supported clients to generate visual chunks beyond interaction distance. |
| `player-position-acceptance-threshold` | Controls tolerance for client and server position differences. |
| `server-authoritative-movement-strict` | Enables stricter correction of player movement differences. |
| `server-authoritative-entity-interactions-strict` | Enables stricter validation of entity interactions. |
| `server-authoritative-dismount-strict` | Enables stricter validation of dismount positions. |
## Scripting and diagnostics properties
| Property | Accepted value or purpose |
| --------------------------------- | ------------------------------------------------------------------ |
| `content-log-file-enabled` | Writes content errors to a log file when enabled. |
| `allow-inbound-script-debugging` | Allows the script debugger to listen for a connection. |
| `allow-outbound-script-debugging` | Allows the script debugger to connect outward. |
| `script-debugger-auto-attach` | `disabled`, `connect`, or `listen`. |
| `script-debugger-passcode` | Passcode used by a permitted debugger connection. Keep it private. |
| `script-watchdog-enable` | Enables monitoring for scripts that hang or exceed limits. |
| `script-watchdog-memory-limit` | Script memory limit in megabytes; `0` disables the limit. |
| `script-watchdog-memory-warning` | Combined script memory usage that produces a warning. |
Leave advanced debugging, movement-validation, compression, and watchdog settings unchanged unless an add-on author or Purpify support gives you a specific value.
## Common configuration tasks
Set `allow-cheats` safely and restart the server.
Choose Peaceful, Easy, Normal, or Hard.
Restrict the server to approved Xbox Gamertags.
Edit configuration files and keep safe copies.
# Whitelist Bedrock players
Source: https://docs.purpify.host/bedrock/whitelist
Restrict a native Minecraft Bedrock Edition server to approved Xbox Gamertags.
Use the allowlist to restrict a native Minecraft Bedrock Edition server to approved Xbox Gamertags. Minecraft Bedrock Edition uses the term `allowlist`, although it also accepts `whitelist` as a command alias.
Add yourself before enabling the allowlist. Otherwise, you may be unable to reconnect until you add yourself through the Purpify game panel console.
## Before you begin
* Start the server and wait until it finishes loading.
* Use each player's exact Xbox Gamertag, including spaces and capitalization.
* Put a Gamertag in quotation marks when it contains spaces, such as `"Example Player"`.
* Confirm that this is a native Bedrock server. For Bedrock players joining through Geyser, use the Java server's allowlist or permission system.
## Enable the allowlist
Open the game panel console and add each player's exact Xbox Gamertag. Enter console commands without a leading `/`.
```text theme={"dark"}
allowlist add "Example Player"
```
Stop the server before editing `server.properties` so the running process does not overwrite your change.
Open the file manager, edit `server.properties`, and set `allow-list` to `true`. Save the file.
```properties theme={"dark"}
allow-list=true
```
Start the server and watch the console for startup errors.
List the allowlisted players and confirm that the expected Gamertags appear.
```text theme={"dark"}
allowlist list
```
## Manage the allowlist
| Task | Method |
| ---------------------------------------- | ------------------------------------------------------------------------------------- |
| Add a player | `allowlist add "Example Player"` |
| Remove a player | `allowlist remove "Example Player"` |
| List approved players | `allowlist list` |
| Reload `allowlist.json` after editing it | `allowlist reload` |
| Disable the allowlist | Set `allow-list=false` in `server.properties`, save the file, and restart the server. |
Removing a player from the allowlist prevents the next connection attempt. If the player is already connected, [kick the player](/bedrock/kick-player) as well.
## Fix common problems
Run `allowlist list` and compare the Gamertag exactly. Add the player again if needed, then run `allowlist reload`.
Confirm that the server is running native Minecraft Bedrock Edition. Enter commands without `/` in the game panel console and with `/` in Minecraft chat.
Geyser provides Bedrock-to-Java cross-play. Manage the player with the Java server's allowlist or plugin permission system instead of this native Bedrock procedure.
# Cancel a service
Source: https://docs.purpify.host/billing/cancellations
Cancel a Purpify hosting service immediately or at the end of its billing cycle.
Back up any server data you want to keep before requesting cancellation.
**Cancel immediately** can end access to the service now. Download or back up required files before selecting it.
## Cancel a service
Sign in at [payments.purpify.host/services](https://payments.purpify.host/services/).
Open the service you want to cancel. Check the service name before continuing.
Select **Cancel Immediately** to cancel now, or **Cancel at End of Billing Cycle** to keep the service until the current billing cycle ends.
Review the selected cancellation timing, then confirm the request.
## Which option should you choose?
| Option | Use it when |
| ---------------------------------- | ----------------------------------------------------------------------------- |
| **Cancel Immediately** | You want the service cancelled now and have already saved the files you need. |
| **Cancel at End of Billing Cycle** | You want to keep using the service for the rest of the current billing cycle. |
## Refunds
Cancellation does not automatically confirm refund eligibility. Follow [Request a refund](/billing/refunds) to read the current policy and open a support ticket if your payment qualifies.
# Discounts
Source: https://docs.purpify.host/billing/discounts
Find out where Purpify announces seasonal and special-occasion discounts.
Purpify often runs seasonal discounts and offers for special occasions. We announce every available discount in the **announcements** channel of the [Purpify Discord](https://discord.gg/purpify).
If no discount is currently announced, watch the **announcements** channel for the next offer.
# Invoices and payments
Source: https://docs.purpify.host/billing/invoices
Open and pay your latest Purpify invoice from the billing portal.
Your Purpify invoices are available on the billing portal's invoice page.
## Pay your latest invoice
Sign in at [payments.purpify.host/invoices](https://payments.purpify.host/invoices).
Open the newest invoice that still requires payment.
Confirm the service, total, and invoice details before continuing.
Use the payment action shown on the invoice and complete the requested payment steps.
Return to the invoice page and confirm that its status has updated.
Do not pay an invoice if the service or total is not what you expected. Contact Purpify support before continuing.
# Upgrade or downgrade a service
Source: https://docs.purpify.host/billing/manage-service
Upgrade or downgrade an active Purpify hosting service from the billing dashboard.
Use the Purpify billing dashboard to change the plan for an active hosting service.
## Upgrade or downgrade
Sign in at [payments.purpify.host/dashboard](https://payments.purpify.host/dashboard).
Select **Active Services** from the dashboard.
Find the service you want to change, then select **Upgrade**. Use this action for both upgrades and downgrades.
Select the upgrade or downgrade you want. Review the displayed plan and payment details before confirming the change.
The billing portal shows the available changes for the selected service.
## Cancel instead
To stop a service instead of changing its plan, follow [Cancel a service](/billing/cancellations).
# Billing overview
Source: https://docs.purpify.host/billing/overview
Use the Purpify billing portal to manage services, invoices, payment details, renewals, and cancellations.
Purpify billing is managed separately from the game panel. Use the billing portal for services and payments; use the game panel for server files and runtime controls.
## Billing guides
Learn how long setup can take and when to contact support.
Find seasonal and special-occasion offers in the Purpify Discord.
Open an active service and upgrade or downgrade it.
Open your invoices and pay the latest invoice.
Cancel immediately or at the end of the billing cycle.
Check the current policy and open a support ticket.
Back up server data before a service expires or is cancelled. Billing cancellation and server-data deletion may follow different timelines.
# Service provisioning
Source: https://docs.purpify.host/billing/provisioning
Learn how long Purpify service provisioning can take and what to do if it takes more than eight hours.
Purpify normally provisions a new service in under five minutes. In certain circumstances, provisioning may take up to eight hours.
You do not need to take any action while the service is provisioning. Check the billing portal for updates.
If your service has not been provisioned after eight hours, contact Purpify support immediately through the billing portal. The support team will create the service and compensate you for the delay.
# Request a refund
Source: https://docs.purpify.host/billing/refunds
Check the Purpify refund policy and open a support ticket when your payment meets its requirements.
Read the current refund policy before submitting a request. If your payment fits the policy, open a support ticket through the Purpify website.
## Request a refund
Check the [current refund policy](https://purpify.host/refund-policy) for eligibility, exclusions, and any requirements that apply to your payment.
Compare your purchase and reason for requesting a refund with the current policy. Do not assume that cancelling a service automatically creates a refund.
Go to the [Purpify website](https://purpify.host) and open a support ticket. Submit the ticket from the account connected to the purchase when possible.
Provide the service name, invoice number, payment date, and a concise explanation of why you are requesting the refund.
Never include your password, full card number, bank credentials, or authentication codes in a support ticket.
Submitting a ticket does not guarantee approval. Purpify reviews each request against the refund policy that applies to the payment.
# Purpify documentation
Source: https://docs.purpify.host/index
Set up and manage Purpify Minecraft Java and Bedrock servers, Geyser cross-play, the game panel, and billing.
Java, Bedrock, and Geyser
Everything you need to run your Minecraft server.
Learn the Purpify panel, connect your players, customize your server, and manage your service.
# Common Java server commands
Source: https://docs.purpify.host/java/admin-commands
Use common Minecraft Java Edition administration commands from the Purpify console or in-game chat.
Run commands without `/` in the Purpify game panel console. In Minecraft chat, add `/` and use an account with sufficient [operator access](/java/manage-players).
## Player and world commands
| Task | Console command |
| ----------------------------------- | ------------------------------------ |
| Change a player's game mode | `gamemode MODE PLAYER` |
| Teleport a player to another player | `teleport PLAYER DESTINATION_PLAYER` |
| Teleport a player to coordinates | `teleport PLAYER X Y Z` |
| Give an item | `give PLAYER ITEM [AMOUNT]` |
| Clear a player's inventory | `clear PLAYER` |
| Set the default game mode | `defaultgamemode MODE` |
| Change the difficulty | `difficulty DIFFICULTY` |
| Save the world immediately | `save-all` |
Replace the uppercase placeholders with real values. Valid modes are `survival`, `creative`, `adventure`, and `spectator`. Valid difficulties are `peaceful`, `easy`, `normal`, and `hard`. Player names containing spaces are not valid Java Edition usernames.
## Set the world spawn
Stand at the intended location and run this in Minecraft chat:
```text theme={"dark"}
/setworldspawn
```
From the console, provide coordinates and an optional dimension:
```text theme={"dark"}
execute in minecraft:overworld run setworldspawn
```
The individual respawn point created by a bed, respawn anchor, or `spawnpoint` is separate from the world spawn.
## Target selectors
Use selectors carefully because a command can affect many players.
| Selector | Target |
| -------- | ------------------------------------------------------------------------------------------- |
| `@a` | All players |
| `@p` | Nearest player to the command source |
| `@r` | Random player |
| `@s` | The entity running the command; behavior from the console may differ from an in-game player |
Test destructive commands on a backup or a limited target first. Commands such as `clear`, `kill`, and large `fill` operations can cause irreversible changes.
# Change the Java server difficulty
Source: https://docs.purpify.host/java/change-difficulty
Set a Purpify Minecraft Java Edition server to Peaceful, Easy, Normal, or Hard.
Choose `peaceful`, `easy`, `normal`, or `hard`. Use `server.properties` when the setting must persist after a restart.
## Change difficulty temporarily
Start the server and enter the command without `/`.
```text theme={"dark"}
difficulty normal
```
Join as an [operator](/java/manage-players) and include `/`.
```text theme={"dark"}
/difficulty normal
```
Replace `normal` with `peaceful`, `easy`, or `hard`. A command-based change can revert when the server restarts.
## Make the difficulty persistent
Stop the server before editing its configuration.
Open the file manager and select `server.properties`.
Enter one supported value.
```properties theme={"dark"}
difficulty=normal
```
Save the file and start the server. Run `difficulty` in the console to confirm the active value.
Review other persistent Java server settings.
# Enable and obtain Java command blocks
Source: https://docs.purpify.host/java/command-blocks
Enable command blocks and give one to an operator on a Purpify Minecraft Java Edition server.
Command blocks run server commands from the world. Only trusted operators should create or edit them.
## Enable command blocks
Stop the Java server before editing its world settings.
Open the server in the Purpify game panel and go to **World Manager**.
Find the world currently used by the server and select **Edit**.
Go to **Game Rules** and enable command blocks.
Save the change and start the server again.
Stop the server, open `server.properties`, and set:
```properties theme={"dark"}
enable-command-block=true
```
Save the file and restart the server.
## Give an operator a command block
Run this in the panel console:
```text theme={"dark"}
give ExactJavaUsername minecraft:command_block
```
Or join with [operator access](/java/manage-players) and run:
```text theme={"dark"}
/give ExactJavaUsername minecraft:command_block
```
On clients with an **Operator Items Tab** option, enable it under controls, switch to Creative mode, and use the Operator Utilities inventory tab.
A repeating or chained command block can change large areas or run commands continuously. Create a backup before testing command-block automation.
Configure command blocks and other world mechanics.
Control who can use administrative commands.
# Connect to a Java server
Source: https://docs.purpify.host/java/connect
Add a Purpify Minecraft Java Edition server in Multiplayer using its address or an optional subdomain.
Copy the connection address from the Purpify game panel, then add it in the Minecraft Java Edition **Multiplayer** menu.
## Before you connect
Confirm that:
* The server status is running.
* Your Minecraft client uses a version supported by the server.
* You installed any mods required by the server.
* You are on the allowlist when the server uses one.
## Add the server
Sign in at [panel.purpify.host](https://panel.purpify.host), open the server, and copy its connection address.
If the panel shows the address and port separately, enter them together as `address:port`.
In Minecraft Java Edition, select **Multiplayer** > **Add Server**.
Enter any name in **Server Name**. Paste the Purpify connection address into **Server Address**.
Select **Done**, choose the server from the list, and select **Join Server**.
The connection works when the server opens and you reach its world or configured login area.
## Add an optional subdomain
A subdomain gives players a named address they can use instead of the default server address.
Manage the server in the Purpify game panel and go to **Network**.
Add a subdomain for the server and choose the available name you want.
Copy the complete subdomain shown in **Network**.
Paste the subdomain into Minecraft's **Server Address** field, save the entry, and join.
## Fix connection problems
Confirm that the Purpify panel shows the server as running. Copy the address again and check that the port is present when required.
Open **Versions** in the Purpify panel and check the server's Minecraft version. Launch a compatible Java client version.
Install the same required mod loader, mod versions, and dependencies used by the server.
Add the player's exact, case-sensitive Java username to the whitelist. Follow [Manage Java players](/java/manage-players) for the console commands and access warning.
Copy the subdomain again from **Network** and test the default Purpify address. If the default address works, check the subdomain configuration in the panel.
# Connect a custom domain to a Java server
Source: https://docs.purpify.host/java/custom-domain
Point play.example.com to a Purpify Minecraft Java Edition server with DNS address and SRV records.
Use an address record for the server IP and an SRV record when players must be sent to a non-default server port. After DNS is configured, Java players can connect with an address such as `play.example.com`.
This guide applies to Minecraft Java Edition. Native Bedrock clients do not all resolve Minecraft SRV records consistently, so Bedrock players may still need the Purpify server address and server port.
## Address and port are separate
| Value | Example | Purpose |
| -------------- | ------------------ | ------------------------------------------------- |
| Server address | `203.0.113.20` | Identifies the server on the network. |
| Server port | `25570` | Identifies the Minecraft service on that address. |
| Custom domain | `play.example.com` | Gives players a memorable name to enter. |
An `A` record maps a hostname to an IPv4 address. It does not carry a port. An SRV record tells compatible clients which hostname and port provide a service.
Use the address and port assigned in the Purpify game panel. Do not change `server-ip` or `server-port` in `server.properties` to match your domain.
## Configure a server on the default port
When the Purpify allocation uses the standard Java port, create an address record:
| DNS field | Example value |
| ---------------- | ----------------------------------------- |
| Type | `A` |
| Name or host | `play` |
| Value or content | `203.0.113.20` |
| TTL | Automatic or your provider's normal value |
Replace the example IP with the address assigned to your server. Players then connect with `play.example.com`.
## Configure a server with a custom port
First create a hostname for the server address:
| DNS field | Example value |
| ---------------- | -------------- |
| Type | `A` |
| Name or host | `mc-origin` |
| Value or content | `203.0.113.20` |
Then create the Minecraft Java SRV record:
| DNS field | Example value |
| --------- | ----------------------- |
| Type | `SRV` |
| Service | `_minecraft` |
| Protocol | `_tcp` |
| Name | `play` |
| Priority | `0` |
| Weight | `0` |
| Port | `25570` |
| Target | `mc-origin.example.com` |
Some DNS providers combine the service, protocol, and name into `_minecraft._tcp.play`. Replace the example address and port with the Purpify values.
If your DNS provider offers an HTTP proxy, CDN, or orange-cloud style proxy, keep the Minecraft record DNS-only unless that provider explicitly supports proxying Minecraft traffic.
## Test and troubleshoot
1. Confirm that the server works with its direct Purpify address and port.
2. Save the DNS records and wait for DNS caches to update.
3. Test `play.example.com` from Minecraft Java Edition.
4. If it fails, confirm the SRV name, target, assigned port, and address record.
5. Make sure the SRV target is a hostname with its own address record and does not end at an unconfigured name.
If you move the server later, update the address and SRV records only after the new server works directly.
# Install Java datapacks
Source: https://docs.purpify.host/java/datapacks
Install, verify, update, and remove datapacks from a Minecraft Java Edition world on Purpify.
Install a datapack in the active world's `datapacks` folder. Datapacks change Java Edition gameplay through functions, recipes, loot tables, advancements, and other data-driven features.
## Install a datapack
Confirm that the datapack supports the server's Minecraft version and read its installation notes. Create a [backup](/server/backups) before adding world-generation or gameplay changes.
Stop the server and check `level-name` in `server.properties`. Open that world folder, then open `datapacks`.
Upload the datapack `.zip` or its extracted folder. Do not add an extra wrapper folder: the datapack's `pack.mcmeta` must be at the top level of the ZIP or folder.
Start the server and run this in the game panel console:
```text theme={"dark"}
datapack list
```
Check the console for an incompatible pack format or validation error.
## Update or remove a datapack
Stop the server before replacing or removing the datapack. Back up the world first, especially when the pack creates dimensions, structures, scoreboards, or persistent data. Start the server and use `datapack list` again to confirm the result.
Removing a datapack does not necessarily undo changes it already made to the world. Follow the datapack author's uninstall instructions when provided.
# Create a flat Java world
Source: https://docs.purpify.host/java/flat-world
Configure a Purpify Minecraft Java Edition server to generate a new Superflat world.
Set `level-type=minecraft:flat`, then generate a new world. This setting does not flatten chunks that already exist.
Create a [server backup](/server/backups). A fresh flat world does not contain the builds or player progress from the current world.
Wait for a clean shutdown before editing files.
Open `server.properties` and set:
```properties theme={"dark"}
level-type=minecraft:flat
```
Follow [Reset a Java world](/java/reset-world), then start the server. The setting applies when the new world generates.
Join the server and confirm that new terrain uses the flat preset.
To return to standard terrain, set `level-type=minecraft:normal` and generate another fresh world. Changing the property alone does not rebuild existing chunks.
# Allow flying on a Java server
Source: https://docs.purpify.host/java/flying
Prevent legitimate flying players from being disconnected from a Purpify Minecraft Java Edition server.
Set `allow-flight=true` when a plugin, mod, or game mode lets players fly. This property permits flight checks; it does not grant players the ability to fly.
Wait for a clean shutdown before editing the configuration.
Open `server.properties` and set:
```properties theme={"dark"}
allow-flight=true
```
Start the server and test with the plugin, mod, or game mode that provides flight.
Creative and Spectator mode provide their own flying controls. Survival flight normally requires a compatible plugin or mod and the required player permission.
Set `allow-flight=false` to restore the normal flight check. Players using legitimate flight from a plugin or mod may then be disconnected.
# Set game rules on a Java server
Source: https://docs.purpify.host/java/game-rules
Change Minecraft Java Edition game rules through World Manager, the Purpify console, or in-game chat.
Use `gamerule` to change world mechanics without restarting the Java server. Game rule names are case-sensitive.
## Change game rules in World Manager
Stop the Java server before editing its world settings.
Open the server in the Purpify game panel and go to **World Manager**.
Find the world currently used by the server and select **Edit**.
Go to **Game Rules** and change the rules you need.
Save the world settings, start the server, and confirm the new behavior in-game.
## Set a game rule with a command
Start the server, open its console view, and enter the command without `/`.
```text theme={"dark"}
gamerule keepInventory true
```
Join as an [operator](/java/manage-players), open chat, and include `/`.
```text theme={"dark"}
/gamerule keepInventory true
```
Use this format for another rule:
```text theme={"dark"}
gamerule
```
## Common Java game rules
| Rule | Value | What it controls |
| --------------------------- | ----------------- | ------------------------------------------------------------ |
| `keepInventory` | `true` or `false` | Whether players retain inventory and experience after death. |
| `mobGriefing` | `true` or `false` | Whether mobs can change blocks or collect items. |
| `doFireTick` | `true` or `false` | Whether fire spreads and extinguishes naturally. |
| `playersSleepingPercentage` | Percentage | Players required to sleep before skipping the night. |
| `randomTickSpeed` | Number | Frequency of random block ticks. |
| `doMobSpawning` | `true` or `false` | Whether mobs spawn naturally. |
| `doDaylightCycle` | `true` or `false` | Whether time and moon phases advance. |
| `doWeatherCycle` | `true` or `false` | Whether weather changes naturally. |
| `showDeathMessages` | `true` or `false` | Whether death messages appear in chat. |
| `commandBlockOutput` | `true` or `false` | Whether command-block output is sent to operators. |
## Check the current value
Enter a rule without a value:
```text theme={"dark"}
gamerule keepInventory
```
Grant the operator access required for in-game administration.
# Set up Geyser cross-play
Source: https://docs.purpify.host/java/geyser
Install Geyser on a Purpify Java server so Minecraft Bedrock players can connect.
Install Geyser as a plugin on a compatible Java server, start the server once to generate its files, then add a port and update the Geyser configuration.
This guide covers the normal plugin installation for compatible Java server software. Modded servers and proxy networks use different Geyser files and locations.
## How cross-play works
Geyser accepts connections from Minecraft Bedrock Edition and translates them for the Java server. Java players continue using the normal Java address. Bedrock players use the server address and the port configured for Geyser.
Geyser does not convert Java worlds, plugins, or mods into native Bedrock formats.
## Before you begin
You need:
* A running Purpify Minecraft Java server with plugin-compatible software
* Access to the plugin installer or `/plugins` folder
* Permission to add an allocation in the Purpify game panel
* A server backup
Give Geyser its own allocation. Do not reuse a port assigned to another server feature.
## Install and configure Geyser
Use Purpify's plugin installer to install Geyser. For a manual installation, download `Geyser-Spigot.jar` from [GeyserMC](https://geysermc.org/download) and upload it to `/plugins`.
Start the server and wait until startup completes. Geyser creates its configuration files during this start.
Stop the server normally before editing the Geyser configuration.
Go to **Network** in the server management view and select **Add Allocation**. Copy the new port number.
Open `/plugins/Geyser-Spigot/config.yml` in the Purpify file manager.
Find the `bedrock` section. Paste the port from **Network** after `port:`.
```yaml Geyser config theme={"dark"}
bedrock:
# The IP address that Geyser will bind on to listen for incoming Bedrock connections.
# Generally, you should only change this if you want to limit what IPs can connect to your server.
address: 0.0.0.0
# The port that will Geyser will listen on for incoming Bedrock connections.
# Since Minecraft: Bedrock Edition uses UDP, this port must allow UDP traffic.
port:
# Some hosting services change your Java port everytime you start the server and require the same port to be used for Bedrock.
# This option makes the Bedrock port the same as the Java port every time you start the server.
clone-remote-port: false
```
For example, if **Add Allocation** gives you port `19150`, change the line to `port: 19150`.
Save the file and start the server. Check the console for Geyser errors, then connect from Bedrock using the server address and the configured port.
Cross-play works when Java players can connect normally and a Bedrock player can join through the Geyser port.
## Add Floodgate
Floodgate lets Bedrock players join without signing in with a paid Java Edition account.
Download the Floodgate plugin for Spigot from [GeyserMC](https://geysermc.org/download), then upload the Floodgate `.jar` to `/plugins`.
Start the server once, wait for startup to complete, then stop it.
Open `/plugins/Geyser-Spigot/config.yml`. Near the top of the file, find the `java` section directly below the `bedrock` section. Change `auth-type` from `online` to `floodgate`.
```yaml Geyser authentication theme={"dark"}
java:
# What type of authentication Bedrock players will be checked against when logging into the Java server.
# Can be "floodgate", "online", or "offline".
auth-type: floodgate
```
Start the server and connect with a Bedrock account.
Never share Floodgate's `key.pem` file. Anyone with this key may be able to bypass the intended Java authentication path.
## Test the Geyser port
Run this command in the server console with your public server address and configured Bedrock port:
```text theme={"dark"}
geyser connectiontest
```
The connection test helps determine whether the Geyser port is reachable from outside the server.
## Troubleshoot cross-play
Confirm that the server is running, Geyser enabled successfully, and the Bedrock client uses the exact port from `config.yml`. Check that another service is not using the same allocation.
Go to **Network** and confirm that `port` contains the number created through **Add Allocation**. Check that `clone-remote-port` has not overwritten it. Copy the first relevant Geyser error from the console when contacting support.
Confirm that the Floodgate `.jar` is in `/plugins`. In `/plugins/Geyser-Spigot/config.yml`, find the top-level `java` section and set `auth-type: floodgate`, then restart the server.
Update Geyser and verify that the Java server version is supported. Some older Java server versions also require a compatible ViaVersion installation.
Geyser only supports server-side Java mods. Mods that require installation on the Java client cannot be translated for a Bedrock client.
## Detailed video guide
Watch the complete walkthrough when you want to follow the setup visually.
[Open the detailed Geyser video guide on YouTube](https://youtu.be/NwCUhAJCaR0)
For configuration details, see the [official Geyser setup guide](https://geysermc.org/wiki/geyser/setup/) and [official Floodgate setup guide](https://geysermc.org/wiki/floodgate/setup/).
# Enable Java Hardcore mode
Source: https://docs.purpify.host/java/hardcore-mode
Enable or disable Hardcore behavior on a Purpify Minecraft Java Edition server.
Set `hardcore=true` in `server.properties` to enable Hardcore behavior. Create a backup first because player death has lasting consequences.
Back up the server before changing Hardcore mode.
Wait for the server to shut down cleanly.
Open `server.properties` and set:
```properties theme={"dark"}
hardcore=true
```
Save the file, start the server, and confirm the setting before inviting players.
To disable Hardcore behavior, repeat the procedure with `hardcore=false`.
Disabling Hardcore mode does not automatically restore a dead player's inventory, position, or previous game mode. Restore a backup if you need to reverse world and player changes caused by a death.
# Manage Java players
Source: https://docs.purpify.host/java/manage-players
Grant operator access, configure the whitelist, and kick or ban players on a Purpify Minecraft Java Edition server.
Use the Purpify game panel console to manage players on Minecraft Java Edition. Enter console commands without a leading `/`.
Operators can change the world, player data, server settings, and access controls. Grant operator access only to people you trust.
## Grant or remove operator access
Open the server console and run:
```text theme={"dark"}
op ExactJavaUsername
```
Remove operator access with:
```text theme={"dark"}
deop ExactJavaUsername
```
An operator can run the same commands in Minecraft chat with a leading `/`.
## Enable and manage the whitelist
Add yourself and the intended players before enabling the whitelist.
```text theme={"dark"}
whitelist add ExactJavaUsername
whitelist on
whitelist list
```
| Task | Console command |
| ----------------------- | ------------------------------------ |
| Remove a player | `whitelist remove ExactJavaUsername` |
| Reload `whitelist.json` | `whitelist reload` |
| Disable the whitelist | `whitelist off` |
Disabling the whitelist allows anyone with the server address to attempt to connect.
## Kick or ban a player
| Task | Console command |
| ---------------------------------- | -------------------------- |
| Disconnect a player temporarily | `kick ExactJavaUsername` |
| Ban a username | `ban ExactJavaUsername` |
| Ban an IP associated with a player | `ban-ip ExactJavaUsername` |
| List username bans | `banlist players` |
| List IP bans | `banlist ips` |
| Remove a username ban | `pardon ExactJavaUsername` |
| Remove an IP ban | `pardon-ip ` |
You can add a reason after `kick` or `ban`. In Minecraft chat, add `/` before the command and use an operator account with sufficient permission.
Join the server and troubleshoot connection errors.
Enter commands and inspect server output.
# Install Java mods and modpacks
Source: https://docs.purpify.host/java/mods
Install Minecraft Java mods and modpacks with Purpify's installers or upload mod files manually.
Use Purpify's modpack installer or mod installer when the content is available there. For a manual installation, upload compatible mod files to `/mods`.
## Before you install mods
The server and players must use compatible combinations of:
* Minecraft version
* Mod loader
* Mod or modpack version
* Required dependencies
Create a backup before installing or updating mods.
## Install a modpack
Manage the Java server in the [game panel](https://panel.purpify.host), then open Purpify's modpack installer.
Select a release compatible with the Minecraft version and loader you want to use.
Start the installation and wait until the panel reports that it finished.
Start the server, watch the console, and connect with the matching client-side modpack.
## Install an individual mod
Use Purpify's mod installer to find and install a compatible mod. Check whether the mod also needs to be installed on each player's client.
## Install a mod manually
Confirm the mod supports the server's Minecraft version and mod loader. Download every required dependency.
Stop the server before changing mod files.
Upload the mod and its dependencies to the `/mods` folder.
Start the server and check the console for missing dependency, wrong loader, or version errors.
## Diagnose a mod crash
Start with the server console, latest log, and crash report. The most useful error often appears before the final line that says the server stopped.
You can give the relevant error log to an AI assistant such as ChatGPT and ask it to identify:
* The mod named in the first relevant error
* A missing dependency
* A Minecraft or mod-loader version mismatch
* Conflicting mods
* The next safe test to perform
Remove passwords, access tokens, private server addresses, player information, and unrelated log history before sharing logs with an AI service. Treat the AI response as a diagnostic suggestion and verify it before deleting files or changing versions.
Example prompt:
```text theme={"dark"}
This Minecraft Java server crashes during startup.
Identify the first relevant error, the mod or dependency involved,
and the safest next troubleshooting step.
Minecraft version:
Mod loader and version:
Last change:
Relevant error log:
```
If the error names Forge, NeoForge, Fabric, Quilt, a loader version, or an incompatible mod list, follow [Troubleshoot Java mod-loader mismatches](/troubleshooting/mod-loader-errors).
# Minecraft Java Edition
Source: https://docs.purpify.host/java/overview
Set up a Purpify Minecraft Java Edition server with server software, plugins, mods, modpacks, or Geyser cross-play.
Choose Java Edition when players use the Java client or when the server needs Java server software, plugins, mods, or modpacks.
Open game panel
## Choose how the server will run
Choose Vanilla, Paper, Purpur, or another supported Java server type.
Extend compatible server software without requiring client-side installation.
Run matching mod loaders and mod sets on the server and player clients.
Let compatible Bedrock clients connect to a Java server.
Connect multiple Java backend servers through one proxy address.
Grant operator access, use the whitelist, and moderate players.
Configure gameplay, access, world, and performance settings.
Identify server, connection, and client lag.
Point an address such as `play.example.com` to the server.
Erase the complete Java installation and start again.
## Recommended order
1. Create the Java server and select its server software.
2. Start the server once and confirm a Java client can connect.
3. Create a backup.
4. Add one customization at a time.
5. Add Geyser or Velocity after the base Java server works.
Java plugins, Java mods, Bedrock add-ons, and Geyser extensions are different formats. Follow the guide for the server technology you selected.
# Diagnose Java server lag
Source: https://docs.purpify.host/java/performance
Identify server-side, connection, or client lag and profile a Purpify Minecraft Java Edition server with spark.
First identify where the lag occurs. Server-side, connection, and client lag require different fixes.
| Lag type | Common signs |
| ----------- | ---------------------------------------------------------------------------------- |
| Server-side | The world slows for everyone, mobs freeze, or mined blocks reappear. |
| Connection | One or more players have delayed actions or rubber-band while moving. |
| Client | One player's display stutters or loses frames while the server continues normally. |
## Check server-side causes
1. Read the console for repeated errors, watchdog warnings, or overloaded messages.
2. Check whether the problem began after adding a plugin, mod, add-on, farm, redstone machine, or large group of entities.
3. Review `view-distance`, `simulation-distance`, and `entity-broadcast-range-percentage` in `server.properties`.
4. Test one change at a time and compare performance under similar player load.
## Profile the server with spark
Use spark on compatible plugin server software to find expensive plugins, tasks, entities, and server threads.
Install a compatible spark `.jar` by following [Install Java plugins](/java/plugins), then restart the server.
Run the profiler during the lag you want to investigate.
```text theme={"dark"}
spark profiler start
```
Let it collect representative activity, then stop it.
```text theme={"dark"}
spark profiler stop
```
Open the generated report link.
Check TPS, milliseconds per tick, memory and garbage collection, then inspect the plugin, mod, world, or thread consuming the most processing time.
A spark report may contain server details. Review it before sharing the link publicly.
Adjust view, simulation, and entity broadcast distances.
Generate chunks before high-speed exploration.
# Install Java plugins
Source: https://docs.purpify.host/java/plugins
Install Minecraft Java plugins with Purpify's one-click installer or upload plugin files manually.
Use Purpify's plugin installer for a one-click installation, or upload plugin files to the `/plugins` folder.
## Before you install a plugin
Confirm that:
* The server uses Java software that supports plugins.
* The plugin supports the server's Minecraft version.
* Every required dependency is installed.
* You created a backup before changing a working server.
## Install with the plugin installer
Sign in to the [game panel](https://panel.purpify.host) and manage your Java server.
Open Purpify's plugin installer from the server management view.
Search for the plugin, confirm its supported Minecraft versions, and select the release you want.
Install the plugin, then restart the server and check the console for dependency or compatibility errors.
## Install a plugin manually
Download the plugin `.jar` from a source you trust. Confirm that the release supports your server software and Minecraft version.
Stop the server before changing plugin files.
Upload the plugin `.jar` to the `/plugins` folder.
Start the server and read the console. A successful first start normally creates the plugin's configuration files inside `/plugins`.
## Update or remove a plugin
To update a plugin, stop the server and replace its `.jar` with a compatible newer release. Keep the existing configuration unless the plugin author requires a migration.
To remove a plugin, stop the server and remove its `.jar` from `/plugins`. Keep a backup of its data folder until you confirm the server works without it.
## If the server does not start
Read the first relevant plugin error in the console. Check the plugin version, missing dependencies, and server software before removing other files. Follow [Troubleshoot Java plugin errors](/troubleshooting/plugin-errors) for a symptom-based workflow.
# Pregenerate a Java world
Source: https://docs.purpify.host/java/pregenerate-world
Use Chunky to generate Minecraft Java Edition chunks before players explore them.
Pregeneration creates and saves chunks before players explore them. This shifts terrain-generation work to a controlled period but uses additional storage.
## Before you begin
* Use Java server software that supports plugins, such as Paper or another compatible Bukkit-based server.
* Install a Chunky release compatible with the server's Minecraft version.
* Create a [backup](/server/backups).
* Choose a reasonable center and radius based on available storage.
## Pregenerate with Chunky
Follow [Install Java plugins](/java/plugins) and install the compatible Chunky `.jar` in `/plugins`.
Start the server and confirm that Chunky loads successfully in the console.
Replace `world` with the active world name.
```text theme={"dark"}
chunky world world
```
Choose the center coordinates and radius in blocks.
```text theme={"dark"}
chunky center 0 0
chunky radius 5000
```
Run the task and monitor the console and storage usage.
```text theme={"dark"}
chunky start
```
Run `chunky help` for the commands supported by the installed Chunky version.
A large radius can consume substantial storage and server resources. Start with a smaller area and do not assume a completion time.
Keep future exploration inside the area you prepared.
# Completely reset a Java server
Source: https://docs.purpify.host/java/reset-server
Erase a Purpify Minecraft Java Edition server installation and start again from the game panel.
Use **Reset** in the server's **Settings** to erase the current Java installation and start with fresh server files.
A complete reset removes worlds, player data, plugins, mods, configurations, logs, and other files stored on the server. Download anything you want to keep before continuing.
## Before you reset
* Confirm that you selected the correct Purpify server.
* Stop the server and download required worlds, configurations, plugin data, or modpack files.
* Export databases separately when you need their saved data.
* Create a [server backup](/server/backups) and keep an external copy of irreplaceable files.
* Record the Java server software, Minecraft version, mod loader, and any extra port allocations you need to recreate.
## Reset the server
Use a normal stop and wait until the console confirms that the process ended.
Open the Java server in the Purpify game panel and go to **Settings**.
Find the reset section and select **Reset**.
Confirm the server name and read the displayed warning. Continue only if you no longer need the files currently stored on the server.
Wait for the reset to finish, choose the required Java software and version, then start the fresh server. Watch the console until startup completes.
If you only want a fresh world, use [Reset a Java world](/java/reset-world). A world reset keeps plugins, mods, and most server configuration.
Select the Java software and Minecraft version after resetting.
Restore a complete server from another host or local copy.
# Reset a Java world
Source: https://docs.purpify.host/java/reset-world
Generate a fresh Minecraft Java Edition world on a Purpify server without deleting unrelated server files.
Reset only the active world folders when you want fresh terrain while keeping the rest of the server configuration. This permanently removes builds, inventories stored in the world, and explored dimensions unless you keep a backup.
## Reset the world safely
Create and verify a [server backup](/server/backups). Download the current world if you may want to restore it later.
Wait until the console confirms a clean shutdown.
Open `server.properties` and note `level-name`. Plugin server software may store the Nether and End in related folders ending in `_nether` and `_the_end`.
Rename the active world folders to keep a temporary copy, or remove them only after confirming the backup. Do not remove plugin, mod, or configuration folders.
Leave `level-seed` empty for a random seed, or enter the seed for the new world. Changing this value does not alter terrain that already exists.
Start the server and let it generate the new world. Join and confirm the world, Nether, End, and spawn are correct before removing temporary copies.
A world reset is different from a full server reset. A full reset also removes plugins, mods, configurations, logs, and other server data.
# Add a Java server resource pack
Source: https://docs.purpify.host/java/resource-pack
Prompt or require Minecraft Java Edition players to download a resource pack from your Purpify server.
Host the resource-pack `.zip` at a direct public download URL, then add that URL to `server.properties`.
## Before you begin
* Confirm that the pack supports the server's Minecraft version.
* Keep the pack as a `.zip`; do not extract it on the server.
* Test the direct link in a private browser window. It must download the file without requiring a sign-in or confirmation page.
* Create a [backup](/server/backups).
## Host the pack
You can upload the resource-pack `.zip` to [MCPacks](https://mc-packs.net/) and use the generated link in `server.properties`.
Upload the pack and copy its server resource-pack link.
## Configure the resource pack
Stop the Java server before editing `server.properties`.
Open the file manager and select `server.properties`.
Paste the direct download URL after `resource-pack=`.
```properties theme={"dark"}
resource-pack=https://downloads.example.com/server-pack.zip
```
Set `require-resource-pack=true` to disconnect players who decline it. Use `false` to let players decline.
```properties theme={"dark"}
require-resource-pack=true
```
Save the file, start the server, and connect with a client that has not cached the pack. Confirm that the download prompt appears.
## Optional integrity settings
* `resource-pack-sha1` accepts the lowercase SHA-1 digest of the pack and lets the client verify the download.
* `resource-pack-prompt` sets custom text for the required-pack prompt.
* `resource-pack-id` identifies the pack with a UUID.
When you replace the pack, update its download URL or SHA-1 value so clients do not continue using an old cached copy.
Review the other settings stored in `server.properties`.
# Add a Java server icon
Source: https://docs.purpify.host/java/server-icon
Display a custom 64 by 64 PNG icon for a Purpify Minecraft Java Edition server.
Upload a `64` by `64` pixel PNG named `server-icon.png` to the Java server's main directory.
## Add the icon
Crop or resize the image to exactly `64` by `64` pixels and save it in PNG format. Partial transparency is supported.
Name the file exactly `server-icon.png`. Confirm that your computer did not add a second extension such as `.png.png`.
Stop the Java server before replacing the existing icon.
Upload `server-icon.png` to the main server directory, next to `server.properties`.
Start the server, refresh it in the Minecraft multiplayer list, and confirm that the new icon appears.
Confirm the dimensions, format, filename, and upload location. Restart the server, then remove and add the server entry again if the client still shows a cached icon.
Upload and replace files through the Purpify game panel.
# Minecraft Java server properties
Source: https://docs.purpify.host/java/server-properties
Edit common Minecraft Java Edition settings in server.properties on a Purpify server.
The `server.properties` file controls gameplay, world generation, access, presentation, and performance for a Minecraft Java Edition server.
## Edit server.properties
Create a [backup](/server/backups) before changing several properties or an unfamiliar advanced setting.
Stop the server so it does not overwrite the file while you edit it.
Open the file manager and select `server.properties` in the main server directory.
Keep each property in `name=value` format without spaces around `=`.
```properties theme={"dark"}
difficulty=normal
```
Save the file, start the server, and check the console for an invalid value or configuration error.
Do not change `server-ip`, `server-port`, query ports, or RCON settings unless Purpify instructs you to. The server must use its assigned network allocation, and RCON traffic is not encrypted.
## Common gameplay properties
| Property | Accepted value or purpose |
| --------------------- | --------------------------------------------------------- |
| `difficulty` | `peaceful`, `easy`, `normal`, or `hard`. |
| `gamemode` | `survival`, `creative`, `adventure`, or `spectator`. |
| `force-gamemode` | Forces the configured game mode when players join. |
| `hardcore` | Enables Hardcore behavior when set to `true`. |
| `allow-flight` | Allows Survival flight used by some mods or plugins. |
| `pvp` | Controls whether players can damage each other. |
| `spawn-protection` | Size of the protected area around world spawn. |
| `op-permission-level` | Controls the default command access granted to operators. |
## World and presentation properties
| Property | Accepted value or purpose |
| ----------------------- | --------------------------------------------------------------------- |
| `level-name` | Selects the active world folder. |
| `level-seed` | Sets the seed used when generating a new world. |
| `level-type` | World preset, such as `minecraft:normal` or `minecraft:flat`. |
| `generate-structures` | Controls structure generation in new chunks. |
| `motd` | Message displayed for the server in the multiplayer list. |
| `resource-pack` | Direct download URL for a Java resource pack. |
| `require-resource-pack` | Disconnects players who decline the server resource pack when `true`. |
## Player and performance properties
| Property | Accepted value or purpose |
| ----------------------------------- | ------------------------------------------------------------------------------------------ |
| `max-players` | Maximum simultaneous players. |
| `player-idle-timeout` | Idle minutes before removal; `0` disables the timeout. |
| `white-list` | Restricts access to `whitelist.json` when `true`. |
| `enforce-whitelist` | Removes players who are no longer listed after a whitelist reload. |
| `online-mode` | Verifies joining players with Minecraft account services. Keep enabled for public servers. |
| `view-distance` | Maximum chunk distance sent to players. |
| `simulation-distance` | Chunk distance in which entities and blocks continue updating. |
| `entity-broadcast-range-percentage` | Scales the range at which entities are sent to clients. |
| `max-tick-time` | Watchdog limit for a server tick, in milliseconds. |
Lower view, simulation, and entity broadcast distances can reduce server load, but they also reduce how far players can see or interact with active entities.
Configure a direct resource-pack download.
Identify server-side, connection, and client lag.
# Choose Java server software and version
Source: https://docs.purpify.host/java/server-software
Switch a Purpify server to Java Edition and select the Minecraft Java version from the game panel.
Use **Software** to choose Java Edition. Use **Versions** to choose the Minecraft Java version the server runs.
## Switch to Java Edition
Sign in at [panel.purpify.host](https://panel.purpify.host) and select the server you want to change.
Back up files and world data before changing the server edition or software.
Go to **Software** and choose Minecraft Java Edition.
Follow the panel prompts, then wait for the software change to finish before starting the server.
Changing from Bedrock to Java does not convert a Bedrock world, behavior pack, or resource pack into a Java-compatible format.
## Choose a Java version
Open the Java server in the game panel and go to **Versions**.
Choose your preferred Minecraft Java version.
Confirm that the server software, plugins, mods, modpack, and player clients support that version.
Start the server, watch the console for errors, and connect with a client on the selected version.
## Software and version are different settings
| Setting | What it controls |
| ------------ | --------------------------------------------------------- |
| **Software** | The server edition or software the server runs. |
| **Versions** | The Minecraft Java version used by the selected software. |
If a plugin or mod stops working after a version change, install a release that supports the selected Java version or restore your backup.
# Configure Java spawn protection
Source: https://docs.purpify.host/java/spawn-protection
Change or disable the protected spawn area on a Purpify Minecraft Java Edition server.
Use `spawn-protection` in `server.properties` to control the built-in protected area around the world spawn. Operators can normally build inside this area.
Wait for a clean shutdown.
Open `server.properties` and enter a non-negative whole number. Use `0` to disable built-in spawn protection.
```properties theme={"dark"}
spawn-protection=0
```
Start the server and test block placement near world spawn with a non-operator account.
Protection plugins may enforce a separate spawn region. Changing `spawn-protection` does not change regions managed by a plugin.
# Update a Java world
Source: https://docs.purpify.host/java/update-world
Move a Minecraft Java Edition world to a newer version safely on a Purpify server.
Back up the server, verify software compatibility, and upgrade the world only after selecting the newer Minecraft Java version. Treat a world upgrade as one-way.
## Update the world
Confirm that the target Minecraft version supports your server software, plugins, mods, mod loader, datapacks, and world-generation settings. Update or remove incompatible content first.
Stop the server, create a [backup](/server/backups), and download the world when possible. Do not rely on a copy that the running server is still writing.
Follow [Choose Java server software and version](/java/server-software) and select the target version. Avoid changing server software and Minecraft version in the same test when you can separate the changes.
Allow the server to convert and save the world. Do not interrupt it during conversion. Stop and restore the backup if the console reports an incompatible world or repeated conversion failure.
Check player data, spawn, dimensions, commands, farms, plugins, mods, and datapacks. New terrain features normally appear only in chunks generated after the upgrade.
Do not open the upgraded world in an older Minecraft version. Downgrading can remove blocks, entities, items, or entire chunks.
# Upload a Java world
Source: https://docs.purpify.host/java/upload-world
Upload an existing Minecraft Java Edition world to a Purpify server and select it in server.properties.
Upload the complete world folder, set `level-name` to that folder's exact name, and restart the server. Use SFTP for large worlds.
## Before you begin
* Confirm that the world is from Minecraft Java Edition.
* Keep an untouched local copy and create a [server backup](/server/backups).
* Stop the server before replacing or selecting a world.
* Do not load a world in an older Minecraft version than the version that last saved it.
## Upload and select the world
Open the world folder and confirm that `level.dat`, the `region` folder, and the other world files are directly inside it. Remove an extra wrapper folder if necessary.
Follow [Manage files and SFTP](/panel/files-and-sftp) and upload the complete folder to the main server directory.
Open `server.properties` and set `level-name` to the exact uploaded folder name.
```properties theme={"dark"}
level-name=MyWorld
```
Start the server, read the console for conversion or loading errors, and join. Check the spawn area, inventories, Nether, and End before removing the old world.
Java and Bedrock worlds use different formats. Uploading a Bedrock world here does not convert it to Java Edition.
## If the server generates a new world
Stop the server and check that:
* `level-name` exactly matches the uploaded folder, including capitalization.
* `level.dat` is directly inside that folder.
* The upload completed without failed or missing files.
* The world is compatible with the selected Java version and server software.
If the server software stores dimensions in separate folders, keep every related world folder together when transferring or restoring the world.
# Set up a Velocity proxy
Source: https://docs.purpify.host/java/velocity
Connect multiple Purpify Minecraft Java servers through a Velocity proxy, including same-node routing with a server UUID.
Velocity lets players join multiple Minecraft Java backend servers through one proxy address. Run Velocity as its own Purpify server, then add each lobby, survival, minigame, or other backend to `velocity.toml`.
## Before you begin
You need:
* One Purpify server running Velocity
* At least one separate Minecraft Java backend server
* The address or server UUID and port for every backend
* File access to the proxy and backend servers
* A backup of every existing backend
Players should connect through the Velocity proxy, not directly to a backend server. Configure player information forwarding before opening the network to players.
## Install Velocity
Create a separate server in the Purpify panel. Open **Versions** and select Velocity.
Start the proxy and wait for startup to complete. This creates `velocity.toml` and `forwarding.secret`.
Stop Velocity normally before editing its configuration.
## Find a backend address
When the Velocity proxy and backend server are on the same node, use the backend server UUID as its hostname.
Select the Minecraft backend server in the Purpify panel.
Go to **Settings** and copy the server UUID.
Copy the port assigned to the backend server.
Use the UUID and port together in `velocity.toml`:
```toml Same-node backend theme={"dark"}
[servers]
lobby = "your-server-uuid:25565"
```
Replace `your-server-uuid` and `25565` with the backend server's values.
Use the backend server address and port shown in its Purpify server management view.
```toml Different-node backend theme={"dark"}
[servers]
lobby = "backend-address:25565"
```
For servers on the same node, do not use `127.0.0.1`. Use the backend server UUID from **Settings**.
## Add backend servers
Open `velocity.toml` on the proxy and find `[servers]`. Give every backend a unique name and enter its connection value.
```toml velocity.toml theme={"dark"}
[servers]
lobby = "lobby-server-uuid:25565"
survival = "survival-server-uuid:25566"
try = [
"lobby"
]
```
The `try` list controls which backend Velocity attempts first when a player joins the proxy.
## Configure modern forwarding
Modern forwarding passes player UUIDs, skins, and other connection information from Velocity to compatible backend software.
In `velocity.toml`, keep the proxy in online mode and set the forwarding mode to `modern`.
```toml velocity.toml theme={"dark"}
online-mode = true
player-info-forwarding-mode = "modern"
```
Open `forwarding.secret` on the Velocity server and copy its complete value.
Stop the backend. In `server.properties`, set `online-mode=false`. Then open `config/paper-global.yml` and enable Velocity forwarding.
```yaml paper-global.yml theme={"dark"}
proxies:
velocity:
enabled: true
online-mode: true
secret: "paste-the-forwarding-secret-here"
```
Configure the same forwarding secret on each Paper backend connected to this proxy.
Never share `forwarding.secret`. A backend in offline mode must be protected by the proxy configuration and forwarding secret.
## Start and test the network
1. Start every backend server and wait until each one is running.
2. Start the Velocity proxy.
3. Check the Velocity console for backend or forwarding errors.
4. Connect to the public address and port of the Velocity proxy.
5. Confirm that you arrive on the first available server in `try`.
## Troubleshoot Velocity
Confirm that the backend is running and that its UUID or address and port exactly match the entry in `velocity.toml`. For a same-node backend, recopy the server UUID from **Settings**.
Confirm that the proxy and backend are on the same Purpify node. Use the public backend address when they are on different nodes.
Confirm that the proxy uses `player-info-forwarding-mode = "modern"`, the Paper backend has Velocity forwarding enabled, and both servers use the exact same secret.
Check the order and spelling of the backend names in the `try` list. Every name must match a key in `[servers]`.
Do not share backend addresses with players. Review the forwarding and server-security configuration before using the network publicly.
For more configuration details, read the [official Velocity getting started guide](https://docs.papermc.io/velocity/getting-started/) and [player information forwarding guide](https://docs.papermc.io/velocity/player-information-forwarding/).
# Set a Java world border
Source: https://docs.purpify.host/java/world-border
Choose the center and diameter of the Minecraft Java Edition world border from the Purpify console.
Use the `worldborder` command to choose the center and diameter of the playable Java world.
## Set the border
Decide which `X` and `Z` coordinates should sit at the center. World spawn is a practical choice for many servers.
Start the server and open its console view.
Replace the example coordinates with your chosen values.
```text theme={"dark"}
worldborder center 0 0
```
Replace `10000` with the complete border diameter in blocks.
```text theme={"dark"}
worldborder set 10000
```
Join and confirm that the border surrounds the intended area before inviting players.
Shrinking a border can leave builds or players outside the playable area. Create a backup and check important coordinates first.
Display the seed used by the active world.
Generate chunks inside a chosen area before exploration.
# Find a Java world seed
Source: https://docs.purpify.host/java/world-seed
Display the seed used by the active Minecraft Java Edition world.
Run `seed` in the Purpify game panel console to display the active Java world's seed.
Start the server, open the console, and enter:
```text theme={"dark"}
seed
```
Join with [operator access](/java/manage-players), open chat, and enter:
```text theme={"dark"}
/seed
```
The result appears in the console or chat. Copy the complete value, including a leading minus sign when present.
Changing `level-seed` in `server.properties` does not rebuild terrain that already exists. Use a fresh world when you want all terrain generated from a different seed.
Review `level-seed`, `level-name`, and other world-generation settings.
# Secure your Purpify account
Source: https://docs.purpify.host/panel/account-security
Reset your Purpify passwords, use two-factor authentication when available, protect credentials, and recover from unauthorized access.
Use a unique password for Purpify, keep credentials out of server files and messages, and enable two-factor authentication when your account offers it.
## Reset a forgotten password
1. Open the sign-in page for the [game panel](https://panel.purpify.host) or [billing portal](https://payments.purpify.host).
2. Use the password-reset option for that service.
3. Open the reset message only from the email account connected to Purpify.
4. Choose a new password that you do not use on another website.
5. Update your password manager and remove obsolete saved credentials.
The game panel and billing portal are separate services. Reset the password for the account you cannot access.
## Enable two-factor authentication
If two-factor authentication is available in your account security settings:
Open your account security settings and choose the available two-factor authentication option.
Scan the displayed QR code with a trusted authenticator app or enter the setup key manually.
Enter a current code to finish activation.
Save recovery codes in a password manager or another private location separate from the device running the authenticator.
If no two-factor option appears, use a unique password and protect the connected email account with two-factor authentication.
## Protect panel and SFTP credentials
* Add people through [Subusers](/panel/team-access) instead of sharing your account.
* Use SFTP only with the host, port, and username shown by the game panel.
* Do not place passwords, database credentials, or tokens in screenshots, public logs, or Discord messages.
* Store secrets in a password manager rather than a shared text file.
* Review downloaded plugin, mod, and add-on files before giving them access to server secrets.
* Sign out on shared devices and do not let an SFTP client save credentials there.
## Handle a compromised account
Change the email password, enable its two-factor authentication, and review its active sessions and forwarding rules.
Reset the affected game-panel or billing password from a trusted device. End other sessions when that option is available.
Review shared server users and remove accounts you do not recognize. Rotate database passwords, API keys, plugin tokens, and webhooks that may have been exposed.
Record unexpected invoices, file changes, console commands, user accounts, and approximate times before restoring data.
Open a private support ticket from the Purpify website. Include your account email, affected service, approximate time, and evidence. Never include your password or authentication codes.
After recovering access, restore a known-good [backup](/server/backups) if unauthorized changes affected the server.
# Use the server console
Source: https://docs.purpify.host/panel/console
Read live Purpify server output, send console commands, and collect useful logs for troubleshooting.
The console displays live output from the current server process. You can also use it to send commands supported by your Minecraft edition, server software, plugins, or mods.
## Read console output
Open your server in the Purpify panel and select the console view. Watch it while the server starts, stops, or loads a change.
Console lines can include:
* Normal startup and shutdown progress
* Warnings that do not stop the server
* Errors from server software, plugins, mods, or configuration files
* Player connections and commands
* The reason a server process stopped
When a server stops unexpectedly, scroll upward. The useful error is often several lines before the final shutdown or exit message.
## Send a command
Enter the command in the console input and submit it. Do not add the `/` used in Minecraft chat.
```text theme={"dark"}
list
```
Useful Java Edition examples include:
```text theme={"dark"}
say Server restart in 5 minutes
whitelist list
whitelist add ExactJavaUsername
save-all
```
Commands vary by edition and server software. Plugins and mods may add their own commands or change the required syntax.
Check a command before running it. Console commands can change player data, permissions, world files, and server settings immediately.
## Copy logs for support
Good error context helps support identify the cause without guessing.
Perform the action that fails, then note the approximate time and your timezone.
Start with the first warning or error related to the failure, not only the final process-exit line.
Include several lines before and after the error so the sequence is clear.
Include the server name or ID, Minecraft edition, server software, version, and the last change you made.
Redact passwords, tokens, private keys, SFTP credentials, and personal information before sharing the output.
## Common console errors
This is usually the result, not the original cause. Scroll upward and look for the first error, exception, or failed file load before the shutdown message.
A configuration may be trying to use an unavailable address or port. Check the server's **Network** allocations and the port configured by the affected software or plugin.
The selected server software may be missing, incomplete, or configured with the wrong file name. Confirm the software and version selection, then reinstall it if needed.
The server may have exceeded its available memory. Review recent plugin, mod, view-distance, or player-load changes. Remove or optimize the cause before starting it repeatedly.
A plugin or mod may require another dependency, loader, Minecraft version, or software version. Compare every component's requirements and update or remove the incompatible file.
Check the spelling and syntax. Confirm that the command exists for your Minecraft edition and server software. In the panel console, enter it without a leading `/`.
Follow the startup troubleshooting guide if the console reports an error and the server remains offline.
# Create a server
Source: https://docs.purpify.host/panel/create-server
Purchase a Purpify Minecraft server, choose Java or Bedrock Edition, and open it in the game panel.
Purchase a server at [payments.purpify.host](https://payments.purpify.host), then choose Java Edition or Bedrock Edition during setup.
Go to [payments.purpify.host](https://payments.purpify.host) and sign in.
Select the Minecraft hosting option and server resources you want.
Select Minecraft Java Edition or Minecraft Bedrock Edition.
Go to [panel.purpify.host](https://panel.purpify.host). The new server appears on the **Servers** page after setup completes.
Select **Start** and wait until the status changes to running.
## Change an existing server's edition
Open the server in the game panel, go to **Software**, and select the edition you want.
Create a backup first. Java and Bedrock server files are not interchangeable.
## Next steps
* [Connect to a Java server](/java/connect)
* [Connect to a Bedrock server](/bedrock/connect)
* [Choose Java server software](/java/server-software)
# Create and manage a database
Source: https://docs.purpify.host/panel/databases
Create a Purpify server database and find its endpoint, username, password, and saved data in the game panel.
Use the **Databases** area in the Purpify game panel to create a database for your server and view its connection details.
## Create a database
Open your server in the Purpify game panel and select **Databases**.
Enter or select a database name that helps you identify its purpose.
Select the database host you want to use.
Confirm the creation action and wait for the database to appear in the **Databases** area.
## Find the connection details
After the database is created, open it in **Databases**. The game panel shows:
| Detail | Use it for |
| ---------- | --------------------------------- |
| Endpoint | The database connection endpoint. |
| Username | The database account username. |
| Password | The database account password. |
| Saved data | The data saved in the database. |
Copy these values into the plugin, mod, application, or other server software that requires the database.
Keep the database password private. Do not share it in screenshots, logs, public messages, or configuration files that other people can access.
## Use the database safely
* Create a backup before changing data used by your server.
* Use the connection details only with software you trust.
* Do not delete a database until you have confirmed that no server software still needs its saved data.
* Recheck the endpoint, username, and password when a connection fails.
Check server output when software reports a database connection error.
# Manage files and SFTP
Source: https://docs.purpify.host/panel/files-and-sftp
Upload, download, edit, and organize Purpify server files with the file manager or SFTP.
Use the file manager for quick changes. Use SFTP when you need to transfer large files, complete worlds, modpacks, backups, or many files at once.
## Choose a transfer method
| Method | Best for |
| ------------ | --------------------------------------------------------------------- |
| File manager | Editing a configuration file or transferring a small number of files. |
| SFTP | Moving worlds, modpacks, backups, or many files. |
## Use the file manager
Stop the server before replacing worlds, server software, plugins, mods, or files that the running server may change.
Open your server in the Purpify panel, then go to its file manager.
Open the folder that contains the file you want to change. Keep the existing folder structure unless your installation guide says otherwise.
Upload, download, rename, move, or edit the file. Save text-file edits before leaving the page.
Start the server and check the console for configuration, plugin, mod, or world-loading errors.
### Common file actions
| Action | When to use it |
| ------------------ | --------------------------------------------------------------------------------------------------- |
| Edit | Change a text-based configuration file such as `.properties`, `.yml`, `.yaml`, `.json`, or `.toml`. |
| Upload | Add a plugin, mod, configuration, world, or other server file. |
| Download | Keep a local copy before changing or removing a file. |
| Rename or move | Reorganize files without transferring them again. |
| Archive or extract | Package many files for a faster, more reliable transfer. |
| Delete | Remove a file only after confirming that the server no longer needs it. |
For a large folder, create an archive on your computer, upload it, and extract it in the destination folder. Confirm that extracting it did not create an extra nested folder.
## Connect over SFTP
You can use an SFTP client such as WinSCP or FileZilla.
Open your server in the Purpify panel and copy the SFTP host, port, and username shown in its connection details.
Select **SFTP** as the protocol. Enter the host, port, username, and the password requested by the connection screen.
Accept the server identity prompt only after confirming that you entered the Purpify connection details correctly.
Open the destination folder on the server, then upload or download the files. Wait for every transfer to complete.
Confirm that the expected files and folders are present before disconnecting or starting the server.
Use **SFTP**, not FTP or FTPS. Never share your SFTP password or save it on a shared computer.
### If SFTP does not connect
* Copy the host, port, and username from the panel again.
* Confirm that the client protocol is set to **SFTP**.
* Make sure you are using the credentials for the correct Purpify server.
* Check whether a local firewall or network is blocking the connection.
* Re-enter the requested password instead of using an old saved credential.
## File safety
* Create a backup before replacing a world or making a large change.
* Stop the server before changing files that it may write while running.
* Download a copy before editing or deleting an important file.
* Change one thing at a time, then start the server and check the console.
* Do not edit binary files in the text editor.
* Do not delete a file if you do not know what it does.
* Keep passwords, tokens, private keys, and SFTP credentials out of screenshots and support messages.
* Follow the folder structure required by your server software, plugin, mod, or modpack.
# Migrate a Minecraft server to Purpify
Source: https://docs.purpify.host/panel/migrate-server
Move a complete Java or Bedrock server from another host with Purpify's Importer and the old provider's SFTP details.
Use Purpify's **Importer** with the SFTP connection details from your old hosting provider. Match the source server's edition, Minecraft version, and server software before starting the imported files.
## Record the source configuration
Before moving files, record:
* Minecraft Java Edition or Minecraft Bedrock Edition
* Exact Minecraft version and server software
* Java mod loader and loader version, when used
* Installed plugins, mods, datapacks, or Bedrock add-ons
* Active world name and every related dimension folder
* Any special startup or installation requirements for the server software
## Prepare the Purpify server
1. Create the destination server and select the matching edition, software, and Minecraft version.
2. Keep the Purpify server stopped while the import runs.
3. Find the SFTP details for the server at your old provider. You need the old SFTP host, port, username, and password.
## Import the server
Warn players, perform a normal stop, and leave the source offline. Files copied while the source is running may contain an inconsistent world or player state.
Open the destination server in the Purpify game panel and select **Importer**.
Enter the SFTP host, port, username, and password supplied by your old hosting provider. Use the old server's credentials, not the SFTP details shown by Purpify.
Confirm the source details and start **Importer**. Keep both services available and do not start either Minecraft server while files are transferring.
Wait until the panel reports that the import finished. Do not edit or replace destination files during the transfer.
Start the Purpify server and watch the complete startup for missing files, incompatible software, or version errors.
SFTP credentials give access to the old server's files. Enter them only in Purpify's **Importer**, never in a public message or screenshot. Change the old password after migration if you keep the old service.
## Verify the migration
* Join with the new server address and port.
* Check player inventories, permissions, spawn, and every dimension.
* Test plugins, mods, add-ons, commands, and scheduled tasks.
* Update DNS only after the destination works through its direct address.
* Keep the source service offline but available until the final checks pass.
Check Java world folders and `level-name`.
Check `level.dat`, the `db` directory, and world selection.
# Purpify panel overview
Source: https://docs.purpify.host/panel/overview
Learn where to find servers, account settings, shortcuts, status, groups, and management actions in the Purpify game panel.
The Purpify game panel is the control center for your servers. Open it at [panel.purpify.host](https://panel.purpify.host).
Open game panel
## Server list
The **Servers** page lists every server you can access. Each row shows the server name, server type, current status, group, and available action.
* Select **Start** to launch an offline server.
* Select **Manage** to open a running server.
* Use **Groups** to filter or organize the server list.
* Switch between **Yours** and **Others** to separate owned servers from shared servers.
* Use the list or grid control to change how servers appear.
## Main navigation
| Area | What you use it for |
| ---------------------- | -------------------------------------------------- |
| **Servers** | View, start, group, and manage servers. |
| **Account** | Manage your panel profile and account preferences. |
| **Keyboard Shortcuts** | View shortcuts for common panel actions. |
Administrative accounts may also see an **Admin** area.
## Server statuses
| Status | Meaning |
| -------------------- | ------------------------------------------------------------------------ |
| Running | The server process is online. Select **Manage** to open it. |
| Offline | The server process is stopped. Select **Start** to launch it. |
| Starting or stopping | A power action is still in progress. Wait before sending another action. |
## Start with these guides
Use the **New Server** flow.
Start, stop, restart, and manage a server safely.
Upload and edit server files.
Read server output and run commands.
Create a database and find its connection details.
Host additional Minecraft servers, Node.js, Python, or MCXboxBroadcast.
Add another user and choose their server permissions.
Move worlds, files, databases, and integrations to Purpify.
Protect credentials and recover from unauthorized access.
# Start, stop, and restart a server
Source: https://docs.purpify.host/panel/server-controls
Use Purpify panel power controls safely to start, stop, restart, or force-stop your Minecraft server.
Use the power controls in your server management view to control the server process. Wait for each action to finish before selecting another control.
## What each control does
| Control | Intended use | Player impact |
| ----------- | --------------------------------------------------------------------- | ----------------------------------------------- |
| **Start** | Launch an offline server. | Players can join after startup completes. |
| **Restart** | Apply a setting, plugin, mod, or software change. | Connected players are disconnected temporarily. |
| **Stop** | Perform a normal shutdown. | The server saves its data before going offline. |
| **Kill** | Force an unresponsive process to end. Use this only as a last resort. | The latest unsaved data may be lost. |
## Start a server
Select your server from the Purpify server list.
Select **Start** in the server management view.
Check the **Console** while the server loads. Startup warnings and errors appear here.
Connect only after the panel shows the server as running and startup has completed in the console.
## Stop a server safely
Send a message from the console so players have time to finish what they are doing. For example:
```text theme={"dark"}
say Server stopping soon
```
Use **Stop** to begin a normal shutdown. This gives the server time to save its data.
Do not start another power action while the shutdown is still running.
Enter commands in the panel console without a leading `/`.
## Safe restart workflow
1. Warn connected players that the server will restart.
2. Create a backup before making a major software, world, plugin, or mod change.
3. Save your configuration changes.
4. Select **Restart** once.
5. Watch the console until startup completes.
6. Join the server and confirm that the change works.
If the server fails to return online, read the first relevant error in the console. The final line often reports only that the process stopped, while the useful cause appears earlier.
## When to use Kill
Try **Stop** first. Use **Kill** only when the server process is unresponsive and a normal shutdown cannot complete.
**Kill** ends the process immediately. Recent world or configuration changes that have not been saved may be lost.
After force-stopping the server, inspect the console and logs before starting it again. Repeatedly starting an unhealthy server can hide the original error or create more file changes.
## When a power action is stuck
1. Wait for the current startup or shutdown action to finish.
2. Check the console for an active save, shutdown, crash, or startup error.
3. Refresh the panel to make sure the displayed status is current.
4. If the process still responds, try one normal **Stop** action.
5. If it no longer responds, use **Kill** as a last resort.
6. Review the console before starting the server again.
If the problem continues, send Purpify support the server name or ID, the approximate time of the issue, the action you selected, and the relevant console lines.
Diagnose common startup failures and collect useful error details.
# Splits
Source: https://docs.purpify.host/panel/splits
Use Purpify splits to host additional Minecraft servers, Node.js, Python, and MCXboxBroadcast.
You can create splits to host additional Minecraft servers, applications, and services with Purpify.
## What you can host
* **Minecraft Java Edition** servers
* **Minecraft Bedrock Edition** servers
* **Node.js** applications
* **Python** applications
* **MCXboxBroadcast**, also known as **FriendConnect** or **WorldConnect**
Each server or application has its own files and configuration requirements. Follow the relevant documentation when preparing a split.
# Manage server subusers
Source: https://docs.purpify.host/panel/team-access
Add a subuser to a Purpify server, choose their permissions, and remove their access safely.
Add a subuser when another person needs access to your Purpify server. Each subuser signs in with their own account and receives only the permissions you select.
A subuser with file, console, database, backup, or settings access may be able to read secrets or make destructive changes. Add only people you trust.
## Add a subuser
Sign in to the [game panel](https://panel.purpify.host), open **Servers**, and manage the server from the **Yours** list.
Select the **Subusers** tab. This tab is available to the server owner and accounts with permission to manage subusers.
Use the email address connected to the subuser's Purpify game-panel account. Do not create a shared account.
Select only the actions required for their role. Review file, console, power, backup, database, and settings access separately when those choices are shown.
Complete the invitation, then ask the subuser to sign in with their own account. Shared servers appear under **Servers** > **Others**.
## Choose permissions
| Responsibility | Access normally required | Main risk |
| -------------------------------- | ------------------------------------------ | -------------------------------------------------------- |
| Restart the server | View server and use normal power controls | Interrupting active players or an update |
| Moderate players | View and send console commands | Granting operator access or running destructive commands |
| Manage plugins, mods, or add-ons | View and change files, plus restart access | Reading secrets or breaking startup |
| Restore backups | View and restore backups | Replacing newer world and player data |
| Manage integrations | Files and database details when required | Exposing passwords, tokens, or saved data |
Avoid granting subuser-management or destructive settings permissions unless the person is expected to manage other users or reset the server.
## Remove a subuser safely
Open the **Subusers** tab and remove the subuser. Confirm that the server no longer appears in their shared-server list.
Change database passwords, plugin tokens, webhook URLs, API keys, or other secrets the former subuser could read. Do not change unrelated credentials without a reason.
Check the console, files, server settings, and other subusers for unexpected changes. Restore a known-good backup if server data was altered without approval.
Removing shared access does not undo console commands, file changes, downloads, or secrets the user previously viewed.
# Get started with Purpify
Source: https://docs.purpify.host/quickstart
Purchase a Purpify Minecraft server, choose Java or Bedrock Edition, start the server, and connect.
Purchase your server through Purpify Billing, choose Java or Bedrock Edition, then open the game panel to start and manage it.
## Create your first server
Go to [payments.purpify.host](https://payments.purpify.host) and choose a Minecraft server.
Select Minecraft Java Edition or Minecraft Bedrock Edition during setup.
Sign in at [panel.purpify.host](https://panel.purpify.host). Your server appears on the **Servers** page after setup completes.
Select **Start** on the server row. Wait until the status changes to running, then select **Manage**.
Open the server management view and copy the server address and port.
Follow the [Java connection guide](/java/connect) or [Bedrock connection guide](/bedrock/connect) for your edition.
The server is ready when its status is running and you can join it from the matching Minecraft edition.
## Change the edition of an existing server
Already bought your server? Open the server in the game panel, go to **Software**, and choose the edition you want.
Back up your server before changing editions. Java and Bedrock use different world, plugin, mod, and add-on formats.
## Choose a Java version
Open your Java server in the game panel, go to **Versions**, and choose your preferred Java version.
Check that your server software, plugins, mods, and player clients support the selected version before you change it.
## What to do next
Choose Java software and install plugins, mods, modpacks, or Geyser.
Connect to Bedrock and manage worlds or add-ons.
# Use Purpify docs with AI
Source: https://docs.purpify.host/reference/ai-access
Connect an AI assistant to Purpify documentation through Markdown, llms.txt, llms-full.txt, or Mintlify MCP.
Mintlify exposes Purpify documentation in formats designed for AI retrieval. Use the smallest source that fits your assistant.
## Choose an access method
| Method | Best for | URL pattern |
| --------------- | ------------------------------------------------------------ | ------------------------------------------ |
| Page Markdown | Answering a question about one page | Open a page's **View as Markdown** action. |
| `llms.txt` | Discovering pages before retrieval | `https://YOUR-DOCS-DOMAIN/llms.txt` |
| `llms-full.txt` | Loading all public docs into a small knowledge base | `https://YOUR-DOCS-DOMAIN/llms-full.txt` |
| MCP | Letting an AI search and retrieve the current docs on demand | `https://YOUR-DOCS-DOMAIN/mcp` |
Replace `YOUR-DOCS-DOMAIN` with the production Purpify docs domain after deployment.
## Recommended setup
Use MCP when your AI platform supports it. MCP lets the assistant search current documentation instead of placing every page in every prompt.
Use `llms-full.txt` for a platform that can ingest a single remote text source but cannot use MCP. Refresh the source after documentation changes so the assistant does not answer from an old copy.
## Retrieval instructions for your assistant
Give your assistant rules like these:
```text theme={"dark"}
Answer Purpify questions only from the connected Purpify documentation.
Prefer a page that directly matches the user's task or error.
Distinguish Minecraft Bedrock Edition from Java Edition.
Cite the source page used for each answer.
Do not invent panel labels, URLs, limits, defaults, or supported versions.
When the docs do not contain an answer, say what information is missing and direct the user to Purpify support.
Never request a password or access token.
```
## Test the connection
Ask the connected assistant:
* "How do I upload an existing Bedrock world?"
* "What should I check when nobody can connect?"
* "What files identify a Bedrock world folder?"
* "When should I stop the server before editing files?"
A good answer cites the relevant Purpify page, follows its sequence, and does not add unsupported product details.
## Keep answers accurate
* Update docs and AI sources together.
* Keep one canonical page for each task.
* Add exact errors and supported values after verifying them.
* Review questions that produce no citation or the wrong citation.
* Retest common questions after navigation or terminology changes.
The docs and MCP server must be public for external AI tools to retrieve them. Do not publish private server addresses, account details, or credentials in documentation.
# Frequently asked questions
Source: https://docs.purpify.host/reference/faq
Quick answers about the Purpify panel, Minecraft Java and Bedrock servers, Geyser, backups, and billing.
## Does Purpify support Java and Bedrock Edition?
Yes. Purpify supports Minecraft Java Edition, native Bedrock Edition, and modded servers.
## Can Bedrock players join a Java server?
Use Geyser to provide Bedrock-to-Java cross-play. Geyser is installed on the Java server; it is not the same as running a native Bedrock server. See [Set up Geyser cross-play](/java/geyser).
## Where do I manage my server?
Use the [game panel](https://panel.purpify.host) to manage server power, files, console output, and runtime settings.
## Where do I manage billing?
Use the [billing portal](https://payments.purpify.host) for services, invoices, and payments. See [Billing overview](/billing/overview).
## Where do I find my server address and port?
Open the server in the Purpify game panel and find its connection details.
## Can I install plugins, mods, and add-ons?
Purpify supports Java plugins, Java mods and modpacks, and Bedrock add-ons. Each format has different server-software and client requirements. Start with [Java Edition](/java/overview) or [Bedrock Edition](/bedrock/overview).
## When should I create a backup?
Create a backup before world uploads, software or version changes, plugin or mod changes, add-on changes, and important configuration edits. See [Create and restore backups](/server/backups).
## Where can I check service status?
Open [uptime.purpify.host](https://uptime.purpify.host).
## How do I contact support?
Join the [Purpify Discord](https://discord.gg/purpify). Send the server name or account-visible ID, the exact error, the time and time zone, and the last change you made. Never send a password or access token.
## Can an AI assistant read these docs?
Yes. See [Use Purpify docs with AI](/reference/ai-access) for Markdown, `llms.txt`, and MCP options.
# Minecraft hosting glossary
Source: https://docs.purpify.host/reference/glossary
Definitions for Purpify panel, Minecraft Java, Bedrock, Geyser, server software, and billing terms.
Content that changes a Bedrock world. An add-on can include a behavior pack, a resource pack, or both.
The interface at `panel.purpify.host` where you manage server power, files, console output, backups, settings, and connection details.
The interface at `payments.purpify.host` where you manage services, invoices, and payments.
Software that translates Bedrock client connections for a Minecraft Java Edition server.
Server-side Java extension loaded by compatible server software. A plugin is different from a mod or Bedrock add-on.
Java modification loaded through a compatible mod loader. Many mods must be installed on both the server and player clients.
The server implementation or mod loader that determines available features, plugins, mods, and compatible versions.
Secure File Transfer Protocol. Use SFTP to transfer many or large server files through a compatible client.
The hostname or IP address used to find a server. Some connections also require a separate port.
The numeric network endpoint used with a server address. Java and Bedrock connections may use different transport and port requirements.
# Create and restore backups
Source: https://docs.purpify.host/server/backups
Protect a Purpify Minecraft server before changes and restore it after a failed update or damaged world.
Create a backup before you upload a world, install an add-on, change the server version, or edit important files. A backup is useful only when you know when it was created and can restore it.
## Create a backup
Use a normal **Stop** and wait until the server is fully offline. You can warn players and ask them to disconnect first, or stop the server directly. A normal stop disconnects players and saves the world safely.
Use the backup action in the Purpify control panel. Give the backup a name that describes the state, such as `before-world-upload` or `before-addon-update`.
Do not change or delete server files until the backup reports that it completed successfully.
## Restore a backup
Restoring a backup replaces newer server data. Download or back up the current state first if you might need it later.
Wait until the server is offline.
Choose the backup created before the problem began. Check its name and creation time before continuing.
Start the restore and wait for the control panel to report completion. Do not start the server or edit files during the restore.
Start the server, read the console for errors, and join the world. Confirm the expected world state and server settings.
# Install behavior and resource packs
Source: https://docs.purpify.host/server/install-addons
Install Minecraft Bedrock add-ons from Purpify's catalog or upload add-ons from your device.
Use Purpify's Bedrock add-on installer to add behavior and resource packs to your server. The installer places and activates the required pack files for you.
## Before you begin
* Confirm that the add-on supports your server's Minecraft version.
* Read the add-on author's requirements and dependency list.
* Create a [server backup](/server/backups).
* Test one new add-on at a time.
Add-ons can change world data. Removing an add-on later may not reverse those changes.
## Install an add-on
Open your server in the Purpify panel and go to the Bedrock add-on installer.
Browse Purpify's preconfigured add-ons, or select **Upload** to choose an add-on from your files.
Select the add-on you want and start the installation. Wait until the installer reports completion.
Restart the server and check the console. Join the world and test the add-on's main feature.
The Purpify installer handles the behavior pack, resource pack, and world activation for you.
## Diagnose an add-on problem
| Symptom | Likely cause | What to check |
| ------------------------------- | ------------------------------------------------------ | -------------------------------------------------------------------------------------- |
| Add-on does not work | The add-on is not compatible | Confirm that it supports the server's Minecraft version. |
| Missing dependency error | A required add-on is absent | Install every dependency named by the add-on author. |
| Server fails after installation | The add-on is invalid or conflicts with another add-on | Restore the backup, then install add-ons one at a time. |
| Players see missing textures | The resource pack did not load | Reinstall the add-on and reconnect to the server. |
| Feature requires Beta APIs | The required world experiment is disabled | Follow [Enable Beta APIs](/bedrock/beta-apis) only when the add-on author requires it. |
When an add-on prevents startup, use [Troubleshoot a server that will not start](/troubleshooting/server-wont-start).
# Upload an existing world
Source: https://docs.purpify.host/server/upload-world
Install an existing Minecraft Bedrock world with Purpify's world installer or transfer a large world over SFTP.
Use Purpify's world installer for most Bedrock worlds. Upload your world file and the installer handles the installation for you. For a large world, use SFTP instead.
## Before you begin
* Keep an untouched copy of the original world.
* Create a [server backup](/server/backups).
* Stop the Purpify server before replacing its current world.
* Make sure the world supports the Minecraft version running on the server.
## Install with the world installer
Open your server in the Purpify panel and go to the world installer.
Select the upload option and choose the Bedrock world file from your device.
Keep the page open until the installer reports that the world was installed successfully.
Start the server, watch the console for world-loading errors, and join. Confirm that your builds, inventory, and spawn point are present.
The world installer handles the required world placement and selection for you.
## Upload a large world with SFTP
Large world uploads are more reliable over SFTP.
1. Export or locate the complete Bedrock world folder.
2. Confirm that the folder directly contains `level.dat` and a `db` directory.
3. Stop the server and create a backup.
4. Follow [Manage files and SFTP](/panel/files-and-sftp) to connect and upload the complete folder.
5. Select the uploaded world for the server, then start it and check the console.
If you have a `.mcworld` file, you can open it as an archive and extract the world folder before transferring it. Do not upload an extra wrapper folder: `level.dat` must be directly inside the world folder.
## If a new world appears
A newly generated world usually means the wrong world was selected or its files are nested one folder too deep.
1. Stop the server.
2. Confirm that the uploaded world folder directly contains `level.dat`.
3. Select the uploaded world again.
4. Start the server and check the console.
If the server cannot start after the upload, follow [Troubleshoot a server that will not start](/troubleshooting/server-wont-start).
# Troubleshoot Bedrock add-on errors
Source: https://docs.purpify.host/troubleshooting/bedrock-addon-errors
Fix incompatible behavior packs, resource packs, dependencies, experiments, and script errors on a Purpify Bedrock server.
Confirm the add-on supports the server version, then check its behavior pack, resource pack, dependencies, and required experiments as one complete installation.
## Match the symptom
| Symptom | Likely cause | What to check |
| ------------------------------------ | ----------------------------------------------------------- | ---------------------------------------------------------------------------- |
| Pack does not appear | Invalid archive or incorrect folder structure | Confirm `manifest.json` is inside the actual pack folder. |
| Missing dependency | Required behavior or resource pack is absent | Install every dependency and matching version named by the author. |
| Purple-and-black or missing textures | Resource pack is missing, inactive, or incompatible | Reinstall and activate the matching resource pack. |
| Script or API error | Required experiment is disabled or the API changed | Check the author's version requirements and [Beta APIs](/bedrock/beta-apis). |
| Duplicate UUID or version conflict | Two installed pack manifests conflict | Keep only the intended compatible release after backing up. |
| Server fails after installation | Invalid pack, dependency failure, script crash, or conflict | Restore the pre-installation backup and add packs one at a time. |
## Isolate the add-on safely
Copy the first relevant console message and the add-on name. Do not rely only on the final process-exit line.
Stop the server and create a backup. When available, restore the backup made before the add-on was installed.
Confirm the behavior pack, resource pack, dependency versions, and server version match the author's requirements.
Turn on Beta APIs or another experiment only when the add-on documentation requires it. Restart after changing world experiments.
Install one add-on or dependency set, restart, then test its main feature before adding another pack.
Removing an add-on does not necessarily remove its custom world data safely. Restore a backup or follow the author's uninstall procedure when the pack adds blocks, entities, items, or scripted data.
## Information to collect
When the problem continues, record:
* Bedrock server version
* Add-on name and version
* Behavior and resource pack versions
* Enabled experiments
* First relevant console error
* Whether the problem also occurs on a fresh test world
See [Install behavior and resource packs](/server/install-addons) for the normal installation workflow.
# Troubleshoot Bedrock server lag
Source: https://docs.purpify.host/troubleshooting/bedrock-performance
Identify server, network, or client lag and reduce load on a Purpify Minecraft Bedrock Edition server.
First determine whether the delay affects everyone, one connection, or one device. Lowering random settings will not fix client frame-rate or network problems.
| Lag type | Common signs |
| ----------- | ----------------------------------------------------------------------------------- |
| Server-side | Mobs, blocks, commands, and movement delay for everyone. |
| Connection | One or several players rubber-band or time out while the server continues normally. |
| Client-side | One device loses frames while other players and server ticks remain normal. |
## Check server-side load
1. Read the [console](/panel/console) for watchdog, scripting, add-on, save, or resource warnings.
2. Check whether the problem started after installing an add-on, enabling an experiment, uploading a world, or changing a game rule.
3. Test during similar player activity after each change.
4. Inspect busy areas for excessive entities, ticking blocks, redstone, command blocks, farms, or add-on scripts.
## Adjust Bedrock properties
Stop the server and create a [backup](/server/backups) before editing `server.properties`.
| Property | Performance effect |
| ------------------------------------------------ | -------------------------------------------------------------------------------------------------------- |
| `tick-distance` | Controls how far from players the server continues world simulation. Lower values reduce ticking work. |
| `view-distance` | Controls the requested chunk view distance. Lower values reduce world loading and network traffic. |
| `max-threads` | Controls server worker-thread behavior. Leave it unchanged unless Purpify provides a specific value. |
| `compression-threshold` and compression settings | Affect network CPU and bandwidth tradeoffs. Keep the existing values unless diagnosing a specific issue. |
Change one setting, restart, and compare the same area under similar player load. See [Bedrock server properties](/bedrock/server-properties) for the supported settings.
## Isolate add-ons and experiments
Restore the backup made before the problem when possible. Otherwise, disable the most recently added pack or experiment, restart, and retest. Do not remove several packs at once because dependencies can make the result unclear.
Removing a behavior pack can damage or remove custom entities, blocks, items, and scripts already saved in the world. Test on a backup copy.
## Check connection and client lag
* Confirm that affected players use the correct address and port.
* Compare players on different networks before assuming the server is overloaded.
* Ask one affected player to test without local resource packs and background downloads.
* Check whether only one device has frame-rate problems in the same world area.
* Review the [Purpify service status](https://uptime.purpify.host) for an active incident.
# Troubleshoot connection problems
Source: https://docs.purpify.host/troubleshooting/cannot-connect
Find why Minecraft Bedrock cannot connect to a Purpify server by checking status, address, port, version, and network restrictions.
Most connection failures come from a stopped server, an incorrect address or port, a version mismatch, or a device that does not support external servers.
## Check the server
1. Open the Purpify control panel.
2. Confirm that the server status is running.
3. Read the newest console lines and confirm that startup completed without a fatal error.
4. Copy the current server address and port again.
If the server stops during startup, use [Troubleshoot a server that will not start](/troubleshooting/server-wont-start).
## Check the Minecraft server entry
In Minecraft Bedrock Edition, edit the saved server and verify:
* **Server Address** contains only the hostname or IP address.
* **Port** exactly matches the Purpify port.
* Neither field contains leading or trailing spaces.
* Minecraft is updated to a version compatible with the server.
Delete and recreate the saved server entry when you are unsure whether a hidden space or stale value is present.
## Check the device and network
Some consoles do not provide the same external-server workflow as desktop and mobile editions. Confirm that your device supports adding external Bedrock servers.
To isolate a local network problem:
1. Ask another player on a different network to connect.
2. Restart Minecraft and the device.
3. Disable a VPN or proxy temporarily and test again.
4. Allow Minecraft through local firewall or security software.
## Match the symptom
| Symptom | Next check |
| ---------------------------------- | ------------------------------------------------------------------------- |
| Server always appears offline | Recopy the address and port, then confirm that startup completed. |
| `Unable to connect to world` | Check version compatibility and test from another network. |
| Connection worked before a restart | Check whether the address or port changed. |
| One player cannot join | Check that player's game version, device restrictions, and local network. |
| No players can join | Check server status, console output, and the connection details. |
## Test with a new world
If the server is running but nobody can connect after a world change, test a fresh world to find out whether the current world is causing the problem.
Create a [backup](/server/backups) so you can restore the current world and settings.
Stop the server, then use Purpify's [world installer](/server/upload-world) to install a new world file.
Start the server and try to connect again. If the fresh world works, the original world or one of its add-ons is likely causing the problem.
Restore your backup if you need the original world. Then inspect its add-ons and compatibility before testing it again.
## Information to send support
Include:
* The server name or account-visible server ID
* The exact connection error
* The date and time of the failed attempt, including your time zone
* The Minecraft version and device type
* Whether another player can connect
Never send your password. Send the server address only through a private support channel.
# Remove client-only mods from a server
Source: https://docs.purpify.host/troubleshooting/client-side-mods
Identify a Minecraft Java server crash caused by a client-only mod and remove the incompatible file safely.
A client-only mod uses rendering, menus, input, or other code that is unavailable on a dedicated server. If one is uploaded to `/mods`, the server may stop during startup.
## Identify the incompatible mod
1. Start the server once and read the first relevant error in the [console](/panel/console).
2. Look for a mod name near messages such as `requires environment type CLIENT`, `invalid dist DEDICATED_SERVER`, `NoClassDefFoundError`, or `ClassNotFoundException`.
3. Compare the named file or mod ID with the files in `/mods`.
4. Check the mod author's page to confirm whether it is client-only or has a separate server-compatible release.
A class-loading error can also be caused by a missing dependency or incompatible version. Do not remove unrelated mods merely because their names appear later in the stack trace.
## Remove and test
Leave it stopped while changing mod files.
Download the suspected `.jar` or move it outside `/mods` so you can restore it if the diagnosis is wrong.
Start the server and watch the full startup. If it fails again, diagnose the new first relevant error rather than removing several files at once.
Keep client-only mods on player devices when desired. Server-required mods and dependencies must remain compatible on both sides when the mod author requires them.
For other startup failures, follow [Troubleshoot a server that will not start](/troubleshooting/server-wont-start).
# Troubleshoot server disk usage
Source: https://docs.purpify.host/troubleshooting/disk-space
Find large Minecraft server files, free space safely, and prevent logs, maps, backups, or worlds from filling storage.
A full disk can prevent world saves, backups, uploads, updates, and clean startup. Stop the server before removing files and keep a copy of anything you may need.
## Find what is using space
Check the file manager and server resource information for:
* Large or repeated log and crash-report files
* Old archives, installers, and uploaded migration copies
* Web-map tiles generated by mapping plugins
* Pregenerated or heavily explored worlds and dimensions
* Plugin databases, player analytics, or retained history
* Duplicate modpacks, plugin versions, or unused world folders
* Backups stored as ordinary files inside the server directory
## Free space safely
Use a normal stop so the world finishes saving.
Download old logs, crash reports, archives, or worlds that you may need before removing them.
Remove completed upload archives, obsolete installer files, and duplicate plugin or mod `.jar` files after confirming the active version.
Check map tiles, analytics, logs, and plugin caches. Use the software's documented cleanup or retention settings when available.
Start the server, read the console, join, make a small safe change, and perform a normal stop. Confirm the next start loads that saved state.
Do not delete the active world, `level.dat`, region or Bedrock database files, plugin data, modpack libraries, or unknown files merely because they are large.
## Prevent the problem from returning
* Configure log, map, analytics, and plugin retention where supported.
* Remove migration archives after verifying the migrated server and keeping an external copy.
* Pregenerate only the world area you intend to use and apply a practical world border.
* Review disk usage after adding a web map, large modpack, or world-generation plugin.
* Keep backups according to a deliberate retention plan instead of retaining every copy indefinitely.
If usage appears incorrect or the panel still reports no free space after cleanup, contact Purpify support with the server ID and the largest folders you found.
# Troubleshoot Java mod-loader mismatches
Source: https://docs.purpify.host/troubleshooting/mod-loader-errors
Fix Forge, NeoForge, Fabric, or Quilt loader and version mismatches on a Purpify Minecraft Java server.
The server, every server-required mod, and each joining player's client must use a compatible Minecraft version and mod loader. Forge, NeoForge, Fabric, and Quilt mods are not interchangeable unless the mod author explicitly provides compatibility.
## Record the required combination
Write down the exact:
* Minecraft version
* Loader family: Forge, NeoForge, Fabric, or Quilt
* Loader version
* Mod or modpack release
* Dependency versions
* Java runtime required by that Minecraft and loader release
Do not compare only the mod name. Two files with the same name may target different loaders or Minecraft versions.
## Read the first loader error
| Error pattern | What it usually means |
| ------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
| Mod requires a different Minecraft version | The mod build and server version do not match. |
| Mod requires `fabricloader`, `forge`, `neoforge`, or `quilt_loader` | The wrong loader is installed or its version is outside the required range. |
| Missing mandatory dependency | A library or API mod is absent. |
| Mod is for a newer or older loader version | The loader must be updated or the mod must be changed to a compatible release. |
| Client reports an incompatible mod list | Client and server mod sets or versions differ. |
| Error references client-only rendering or environment code | A client-only mod was uploaded to the server. |
## Correct the mismatch
Stop the server and create a [backup](/server/backups).
Use the modpack manifest or mod author's requirements to choose the Minecraft version, loader family, and loader version.
Select the compatible version in the Purpify installer. Do not mix loader families in the same `/mods` folder.
Upload releases for the selected loader and Minecraft version, including required API or library mods.
Install the same required mod and loader versions on player clients. Keep optional client-only mods off the server.
Start once and read the first remaining error. Join only after the console reports a completed startup.
Review manual and installer-based mod setup.
Remove rendering and interface mods from the dedicated server.
# Troubleshoot Java plugin errors
Source: https://docs.purpify.host/troubleshooting/plugin-errors
Fix missing dependencies, incompatible Java plugins, invalid configuration, and plugin startup failures on Purpify.
Start with the first error that names the plugin. Most plugin failures come from unsupported server software, a missing dependency, an incompatible Minecraft or Java version, or an invalid configuration.
## Identify the failure
Open the [console](/panel/console) during startup and compare the message with these common causes:
| Console message or symptom | Likely cause | Next check |
| -------------------------------------------------- | --------------------------------------------------------------------- | ---------------------------------------------------------------------------- |
| `UnknownDependencyException` or unknown dependency | A required plugin is missing | Install the dependency and a version compatible with the server. |
| `InvalidPluginException` | Wrong file, damaged download, or incompatible plugin build | Download the correct server plugin from its official source. |
| `UnsupportedClassVersionError` | The plugin requires a newer Java runtime | Check the plugin requirements and selected Minecraft server version. |
| `NoClassDefFoundError` | Missing dependency or incompatible API | Find the first plugin named before the stack trace repeats. |
| Plugin is ignored or does not appear | Server software does not support it, or the file is not in `/plugins` | Confirm the server uses compatible plugin software and the file is a `.jar`. |
| Configuration parsing error | Invalid YAML, JSON, or another config format | Restore the last working config and reapply one change. |
## Fix one plugin at a time
Leave the server stopped while changing plugin files.
Back up the server and download the plugin configuration when it contains important data.
Confirm the plugin supports the Minecraft version, server software, and Java runtime used by the server. Install every dependency listed by the author.
Replace an invalid `.jar` with the correct release. To test removal, move the suspected plugin outside `/plugins` rather than deleting its data folder.
Watch the complete startup. If another error appears, diagnose that new first error before changing more plugins.
Avoid `/reload` when diagnosing plugins. Restart the server so plugins load through a clean startup sequence.
For installation steps, see [Install Java plugins](/java/plugins).
# Troubleshoot a server that will not start
Source: https://docs.purpify.host/troubleshooting/server-wont-start
Use the Purpify console and recent server changes to diagnose startup failures, crashes, and restart loops.
When a server will not start, find the first useful console error and undo the most recent change. World uploads, add-ons, configuration edits, version changes, and an unaccepted EULA are common causes.
## Find the first useful error
Open the Purpify console and start the server once. Read the output from the start of that attempt. The last line may only report that the process stopped; the useful error often appears several lines earlier.
Copy the error before changing anything. Remove passwords, tokens, private addresses, and player information before sharing it.
## Undo the latest change
Use the branch that matches what changed immediately before the failure:
Open the server in the Purpify panel and select **Accept EULA**. Start the server again and watch the console until startup completes.
Confirm that the world folder directly contains `level.dat` and that the configured world name exactly matches the folder. Restore the previous world when the uploaded world is damaged or incompatible.
Restore the backup made before installation. Then follow [Troubleshoot Bedrock add-on errors](/troubleshooting/bedrock-addon-errors) to verify packs, dependencies, experiments, and versions.
Leave the server stopped and follow [Troubleshoot Java plugin errors](/troubleshooting/plugin-errors). Check the first named plugin, its dependencies, and compatibility.
Compare the Minecraft version, loader family, loader version, mods, and dependencies. Follow [Troubleshoot Java mod-loader mismatches](/troubleshooting/mod-loader-errors).
Restore the last known working file. Check the edited value's spelling, allowed format, and quotation marks before applying the change again.
Restore a backup created before the version change. Confirm that the world and add-ons support the target version before trying again.
Check the [Purpify service status](https://uptime.purpify.host), [disk usage](/troubleshooting/disk-space), and resource usage, then retry one normal start. Avoid repeated restart loops because they can overwrite useful logs.
## Restore service safely
Leave the server stopped while you inspect files and logs.
Save the relevant console output and note the exact time of the failed start.
Restore a known-good backup or reverse only the latest change.
Watch the complete startup. When the server remains running, join it and verify the affected feature.
## Information to send support
Send the server name or account-visible server ID, failure time and time zone, complete relevant console error, and the last change made. Never send your account password.
# Recover a damaged Minecraft world
Source: https://docs.purpify.host/troubleshooting/world-corruption
Recognize a damaged Java or Bedrock world, preserve evidence, and restore a safe Purpify backup.
Stop repeated restarts and restore the newest known-good backup when a world is damaged. Chunk or world repair can permanently remove terrain, entities, containers, and player changes.
## Signs of possible corruption
* Startup stops while loading the world or a specific dimension.
* The console repeatedly names a chunk, region, `level.dat`, or database file.
* Entering one area crashes the server or disconnects every nearby player.
* A world loads as new, loses a dimension, or reports unreadable data after an interrupted write.
These symptoms can also come from an incompatible Minecraft version, mod, plugin, or Bedrock add-on. Preserve the first relevant console error before changing files.
## Recover safely
Leave the server offline so it does not keep writing to the damaged world or overwrite useful logs.
Download the world and relevant logs. Keep this diagnostic copy even when you plan to restore a backup.
Check the selected world name and folder structure. A wrong `level-name` or an extra wrapper folder can look like missing or damaged world data.
Choose the newest backup created before the first corruption symptom. Follow [Create and restore backups](/server/backups).
Watch the full startup, then test the affected dimension or area before allowing normal play.
## When only one chunk or region is damaged
A specialist world-repair tool may be able to remove or rebuild only the affected region. Work on a downloaded copy, verify the edition and world format, and keep the untouched original. Removing a region regenerates that terrain and permanently deletes builds and data inside it.
Do not delete a region, Bedrock database file, `level.dat`, or dimension folder based only on a guessed filename. Restore a backup or ask support to interpret the exact console error.
If corruption returns after a successful restore, investigate disk-space exhaustion, unsafe force-stops, incompatible world-generation content, or a plugin, mod, or add-on writing invalid data.