LiteBans vs AdvancedBan: which moderation plugin to pick (2026)

Once you cross twenty concurrent players and have an open registration, you cannot run a server without a dedicated punishment plugin. Vanilla Bukkit /ban does exactly one thing: writes a name into banned-players.json and disconnects with a generic message. No history, no reason field, no IP tracking, no proxy sync, no web interface for moderators. Fine for an SMP of ten friends. A nightmare for any network with a proxy and a handful of backends.

Two plugins dominate this niche on the Spigot/Paper side: LiteBans (paid, around 15 USD on BuiltByBit, proprietary) and AdvancedBan (free, MIT, open source). Both are still actively maintained in 2026, both speak per-network bans through MySQL, both cover /ban, /tempban, /mute, /warn, /kick. The differences are in the polish, the web UI, the API surface, and how much time and money you are ready to spend. Let's break it down.

Why a dedicated moderation plugin

Bukkit's built-in /ban does three things: appends a name to a JSON file, kicks the player, prints to console. That falls short almost immediately. You need:

• Punishment history per player. Who issued it, when, for what reason, how many priors.
• Reason and duration in the kick screen. The player should see Banned for: x-ray client / 30 days / appeal: example.com.
• Persistent storage in a real database. JSON corrupts on crash, does not scale, does not sync.
• Per-network bans. If you run a lobby, a survival, and minigames behind Velocity/BungeeCord, a ban on one node should propagate everywhere.
• Mute, warn, kick as first-class entities with their own histories.
• IP and UUID linking. Alts get caught by IP tracking.
• Web UI for moderators who don't have SSH access.
• API for tying into your Discord bot, anticheat, custom plugins.

LiteBans and AdvancedBan both cover this list, but the way they cover it is what makes the difference.

LiteBans: the paid premium standard with full web UI

LiteBans sells on BuiltByBit (formerly part of the SpigotMC marketplace) for around 15 USD. Maintained by a single developer, current major branch is 2.x. Supports Bukkit/Spigot/Paper from 1.8.x to 1.21.x, BungeeCord, Velocity, Sponge. Storage is MySQL/MariaDB-first with PostgreSQL support and an H2 fallback for single-server (not recommended in practice).

The headline feature is the PHP web frontend. Not "an API endpoint", but a fully built admin panel with a punishment table, filters, search by name/UUID/IP, sections for bans/mutes/warns/kicks, full per-player history. Theming is via CSS, default light and dark themes ship in the box. There is an admin login with permissions. Install: drop the litebans-php folder into /var/www/, fill in MySQL credentials in config.php, and the frontend reads the same tables the plugin writes. No separate migrations, no schema duplication.

Command coverage is comprehensive:

/ban <player> [time] <reason>
/tempban <player> <time> <reason>
/ipban <player|ip> [time] <reason>
/mute <player> [time] <reason>
/tempmute <player> <time> <reason>
/warn <player> <reason>
/kick <player> <reason>
/unban <player>
/unmute <player>
/unwarn <id>
/banlist [type]
/history <player>
/staffhistory <staff>
/check <player>      # currently active sanctions
/dupeip <player>     # alts via IP linking

LiteBans also supports layouts: kick screen templates with placeholders like {reason}, {duration}, {banned-by-name}, {appeal-link}. You can define different layouts per punishment type and per duration band. A permanent ban can look completely different from a 7-day ban, which can look different from a mute.

Per-network bans run via shared MySQL. Same database block on every backend and on the proxy, LiteBans writes to one litebans_bans table, the lookup happens on login. On a proxy (BungeeCord/Velocity) there is a dedicated jar that catches the player before forwarding to a backend, which is slightly faster than catching at the backend itself.

The plugin API exposes Bukkit-style events: LiteBansBanEvent, LiteBansMuteEvent, LiteBansWarnEvent, LiteBansKickEvent, LiteBansUnbanEvent. You can subscribe from your own plugin and, for example, pipe each ban into a Discord webhook or call your anticheat backend for cross-reference.

@EventHandler
public void onBan(LiteBansBanEvent event) {
    String target = event.getTargetName();
    String reason = event.getReason();
    String executor = event.getExecutorName();
    long duration = event.getDuration();
    discordBridge.sendBanLog(target, reason, executor, duration);
}

Downsides of LiteBans:

• It costs money. For a 5-player SMP that is overkill.
• Closed source. If the author disappears, no fork is possible.
• MySQL is mandatory in practice. The H2 fallback exists but nobody runs it long-term.
• Web UI needs a separate PHP host. If you live on Pterodactyl with no own webserver, you have to spin up Nginx + PHP-FPM somewhere on the side.

AdvancedBan: the free workhorse

AdvancedBan lives on GitHub under DevLeoko/AdvancedBan with an MIT license. Distributed via Hangar (PaperMC), Modrinth and SpigotMC for free. Supports Bukkit/Spigot/Paper from 1.8 to 1.21+, BungeeCord support via an addon. The jar is three to four times smaller than LiteBans, with no extra dependencies.

Storage out of the box: SQLite or MySQL. SQLite lives in plugins/AdvancedBan/data.db, fine for a single server up to ~100 online. MySQL is enabled by flipping a block in config.yml:

MySQL:
  use-MySQL: true
  ip: 127.0.0.1
  port: 3306
  db-name: advancedban
  username: ab_user
  password: changeme

Commands map almost one-to-one with LiteBans:

/ban <player> <reason>
/tempban <player> <time> <reason>
/ipban <player> <reason>
/mute <player> <reason>
/tempmute <player> <time> <reason>
/warn <player> <reason>
/tempwarn <player> <time> <reason>
/kick <player> <reason>
/unban <player>
/unmute <player>
/punish <player>     # GUI to pick a punishment
/history <player>
/check <player>
/banlist

Time parser accepts s, m, h, d, w, mo, y suffixes (/tempban Notch 7d griefing).

Layouts exist too, in a slightly simpler format than LiteBans:

Ban:
  - "&8&m=================================="
  - "&cYou are banned from this server"
  - ""
  - "&7Reason: &f{reason}"
  - "&7By: &f{operator}"
  - "&7Until: &f{duration}"
  - ""
  - "&7Appeal: &fdiscord.gg/example"
  - "&8&m=================================="

Per-network bans via MySQL: same block on every backend, AdvancedBan writes to a single schema. For BungeeCord there is a separate addon plugin that hooks the proxy login.

Web UI is simpler and not officially in the main repo. Several community forks exist (AdvancedBanWeb, AdvancedBan-Frontend) that read MySQL and render punishment tables. Visuals are spartan, fewer filters, no admin login, no themes. If you want a polished UI with deep filters and search-by-IP, you either build it yourself or migrate to LiteBans.

The AdvancedBan API also exposes events:

@EventHandler
public void onPunish(PunishmentEvent event) {
    Punishment p = event.getPunishment();
    if (p.getType() == PunishmentType.BAN) {
        // forward to Discord
    }
}

Plus a direct repository handle: PunishmentManager.get().getActivePunishments(uuid) returns the list of currently active sanctions.

Downsides of AdvancedBan:

• Web UI is community-only and rougher.
• Layouts have fewer placeholders, less segmentation.
• Translations and templates are spread across multiple yml files, slightly less tidy.
• Slower release pace: major versions land every few months.

Installation flow for both

LiteBans:

1. Buy on builtbybit.com, download LiteBans.jar
2. Drop into plugins/, restart server
3. Open plugins/LiteBans/config.yml and settings.yml
4. Fill MySQL credentials in settings.yml -> sql:
5. Restart, plugin creates litebans_* tables
6. Web UI: extract php frontend into /var/www/litebans/
7. Fill the same MySQL creds in config.php

AdvancedBan:

1. Download AdvancedBan.jar from hangar.papermc.io or github releases
2. Drop into plugins/, restart
3. Open plugins/AdvancedBan/config.yml
4. Switch use-MySQL: true and fill the MySQL block
5. Restart, plugin creates the punishments table
6. Optional: download BungeeCord addon from releases

For a Velocity proxy network:

1. Each backend runs the main jar with identical MySQL block.
2. Velocity runs the corresponding proxy jar (LiteBans-Velocity, AdvancedBanVelocityFix or equivalent fork branch).
3. Login listener on the proxy queries MySQL before forwarding the player to a backend.
4. Each backend re-checks on login event as a fallback.

Commands and a real moderation flow

Imagine a player Hacker_77 is using x-ray. Standard flow:

[Moderator] /check Hacker_77
[Plugin] Active: 1 warn (caps abuse, 2026-04-12)
         History: 3 entries

[Moderator] /tempban Hacker_77 30d x-ray client (proof: clip url)
[Plugin] Hacker_77 banned for 30 days. Reason: x-ray client
[Plugin] Discord webhook fires (via your listener)

[Hacker_77 reconnects]
[Plugin] Kick screen with full layout, reason, duration, appeal link

If, on review, the ban needs to be permanent:

/unban Hacker_77
/ban Hacker_77 x-ray client + bypass attempts (perm)

For chat moderation:

/tempmute spammer 1h spam
/tempmute toxic_kid 1d slurs (proof: log url)

Warns accumulate and can convert to a ban automatically once they cross a threshold via AdvancedBan WarnActions or LiteBans triggers.

Per-network bans on Velocity/BungeeCord

Both plugins do this, the implementations differ. LiteBans uses one MySQL layer shared between proxy and backend. When a player connects to Velocity, the LiteBans Velocity plugin queries litebans_bans, and if a record is active, kicks with the right layout. If a ban is added while the player is online, the proxy sees the INSERT and triggers a kick.

AdvancedBan: the main logic lives on the backend. The Velocity/BungeeCord addon hooks login and queries MySQL. Slightly less centralized but it works.

Trap to avoid: schema must stay in sync across all instances. If two backends run different major versions of LiteBans, one of them might attempt a schema migration that breaks the others. Rule: one plugin version, one upgrade window, all backends bumped together.

Web UIs: where LiteBans pulls ahead

LiteBans Web UI:

• Ready-to-deploy PHP page in the box (included in the purchase).
• Themes: light, dark, custom CSS overrides.
• Filters: by punishment type (ban/mute/warn/kick), by status (active/expired/permanent), by name/UUID/IP.
• Pagination, sortable columns.
• Per-player history one click away.
• Optional admin login layered on top, so the public sees only banlist while staff see full history.

AdvancedBan Web UI:

• No official frontend. Community projects: AdvancedBanWeb (PHP), advancedban-frontend (Node/React) and others.
• Minimum feature set: ban list, search by name.
• No auth tiers, no advanced filters.
• If you want LiteBans-grade UX, easier to build a custom backend or migrate.

For a public server with frequent appeals, the web UI is the line between "manageable" and "unmanageable". A moderator without SSH, an appealing player who wants to see their status, and an owner who wants outside audit all live in the web UI. If your budget allows, LiteBans solves it for you.

Plugin API for custom integrations

Say you want every ban to fire into Discord and into your custom anticheat for cross-check.

LiteBans:

public class BanLogger implements Listener {
    @EventHandler
    public void onBan(LiteBansBanEvent e) {
        String target = e.getTargetName();
        String reason = e.getReason();
        long duration = e.getDuration();
        DiscordWebhook.send(String.format(
            "BAN | %s | %s | %s",
            target, reason, formatDuration(duration)
        ));
    }
}

AdvancedBan:

public class BanLogger implements Listener {
    @EventHandler
    public void onPunish(PunishmentEvent e) {
        Punishment p = e.getPunishment();
        if (p.getType() != PunishmentType.BAN
            && p.getType() != PunishmentType.TEMP_BAN) return;
        DiscordWebhook.send(String.format(
            "BAN | %s | %s | by %s",
            p.getName(), p.getReason(), p.getOperator()
        ));
    }
}

Both are fine. LiteBans gives you a slightly cleaner separation (one event class per type), AdvancedBan gives a single event with a type filter.

Querying the DB directly via your own SQL is technically possible but discouraged: a schema bump breaks you. Use the API.

Migrating data between the two

Common scenario: you started on AdvancedBan, the server grew, you want LiteBans for the web UI, and you need to keep your history.

There is no first-party importer from AdvancedBan to LiteBans. Three approaches:

1. Custom SQL script. AdvancedBan schema: a single punishments table with name, uuid, reason, operator, punishmentType, start, end, calculation. LiteBans: separate tables litebans_bans, litebans_mutes, litebans_warnings, litebans_kicks, litebans_history. Mapping is straightforward: punishment type maps to a target table, milliseconds map to LiteBans timestamps.

-- import bans from AdvancedBan into LiteBans (simplified)
INSERT INTO litebans_bans (uuid, ip, reason, banned_by_uuid, banned_by_name, time, until, server_scope, server_origin, active)
SELECT
    uuid,
    NULL,
    reason,
    NULL,
    operator,
    start,
    CASE WHEN end = -1 THEN -1 ELSE end END,
    '*',
    'global',
    1
FROM advancedban.punishments
WHERE punishmentType IN ('BAN', 'TEMP_BAN');

2. Keep AdvancedBan running read-only on the side. Spin up LiteBans on a fresh DB, leave AdvancedBan only for history lookups. Not pretty but easy.

3. Third-party importer scripts. GitHub has a few, of varying freshness. Always back up the DB first.

The reverse direction (LiteBans → AdvancedBan) is rarer but also a SQL exercise: collapse the per-type tables into a single AdvancedBan punishments table with the type column populated from the source table.

Performance under load

Both handle 200+ concurrent players without sweating. Things that matter:

• Connection pooling. LiteBans uses HikariCP, AdvancedBan also uses HikariCP in recent versions. Default pool size of 10 is enough for almost everyone.
• Async everywhere. Both plugins write to the DB asynchronously. The main thread only checks a cache on login.
• Login query must be cheap. UUID index is a must (both plugins create it). On hundreds of thousands of records, run EXPLAIN SELECT * FROM litebans_bans WHERE uuid = '...' AND active = 1. You want a ref plan over the UUID index.
• MySQL co-located. Run MySQL on the same box as Minecraft, or one private-network hop away. 1-2 ms latency is fine, 20+ ms shows up as login lag.

LiteBans is slightly heavier in memory due to richer caching. The 100 MB jar is misleading, JVM overhead is under 30 MB. AdvancedBan sits around 15-20 MB.

Neither contributes tick lag, provided MySQL is healthy. If MySQL gets slow, async writes do not block the main thread but the fallback queue grows. At 1000+ events per minute that is worth a Prometheus alert.

Cost and license

Item	LiteBans	AdvancedBan
License	proprietary, paid	MIT, free
Price	~15 USD on BuiltByBit	0
Support	active dev replies	community + dev
Web UI	bundled	community forks
Open source	no	yes

If your budget is zero, the choice is obvious. If you can spare 15 USD once, LiteBans saves you hours on web UI setup and layout work.

When to pick which

Pick LiteBans if:

• Large public server, 100+ concurrent.
• Multiple moderators without SSH access, web UI is mandatory.
• Network with proxy, multiple backends, lobbies, you want maximally robust sync.
• Players appeal often, you want a public banlist page.
• 15 USD one-time fee fits the budget.
• You want a finished product, not hours of community-fork wiring.

Pick AdvancedBan if:

• SMP up to 50 concurrent, or whitelisted private.
• Zero budget for paid plugins.
• Open source matters (audit, fork, customisation).
• Web UI is optional or you're fine running your own.
• Simple structure, no complex network routing.
• "Install and forget" is the goal.

Both solve the core task. The gap is in polish and bundled UI.

Pre-production checklist

• MySQL backup configured (mysqldump in cron, daily at minimum).
• Layouts for ban/mute/warn/kick include an appeal URL.
• Permissions split by role (modkick, modban, admin).
• /staffhistory (or equivalent) enabled for accountability.
• Discord webhook fires on every punishment via your listener.
• Test flow: ban → reconnect → kick screen with the right layout.
• Per-network: ban on one node applies on all.
• Web UI (if LiteBans) gated behind auth, full data not publicly browsable.
• DDoS protection (e.g. MineGuard) on top, since 9 out of 10 attacks land right after a permanent ban.

FAQ

Can I run both plugins at once?

Technically yes, especially if you rename one set of commands. Practically never. Two histories, two databases, two logs, two layouts, two places to check. Pick one.

Do both support Velocity 3.x?

LiteBans, yes, ships a dedicated Velocity jar. AdvancedBan partially, via the community fork AdvancedBanVelocityFix or recent main jar releases. Smoke-test on staging before prod.

Is LiteBans worth it without the web UI?

The plugin works without the web UI, sure, but 80% of LiteBans value is the bundled web UI. Without it, AdvancedBan saves you 15 USD without losing function.

SQLite or MySQL for AdvancedBan?

Single server, up to 50 online, no proxy: SQLite is fine. Anything else: MySQL. SQLite cannot back a multi-server setup, the file is single-writer.

Where are player IPs stored?

Both record the last login IP. LiteBans persists it in litebans_history, AdvancedBan caches it for /ipban. Mind GDPR if your audience is in the EU: do not publish raw IPs in a public web UI without hashing.

Can I import history from MaxBans into LiteBans or AdvancedBan?

Yes, via a custom SQL script. No first-party importer that I know of, schemas differ. Back up first, map columns by hand.

A solid moderation plugin is more than commands and tables. It is insurance for tired night-shift moderators, an audit trail for appeals, and a stable API for automation. Both LiteBans and AdvancedBan deliver. The choice boils down to one question: 15 USD for a polished web UI or hours of your time on a community frontend. If your server runs commercially, the answer is straightforward. If it is a private SMP for friends, the answer flips.