Do these 3 things before closing this tab:
1Clear out junk files and repair common Windows errors2Fix the driver behind crashes, sound loss and screen glitches3Repair Windows errors before they cause bigger problemsTo connect centralized banning to a Rust server, you need two pieces: an HTTP or HTTPS ban API and the Rust server convar server.bansServerEndpoint. Facepunch does not provide a ready-made ban server. You must run an API yourself or use one supplied by your hosting provider, then point the Rust server at its base URL. When a player joins, Rust requests GET /api/rustBans/{steamID64} and uses the returned ban or mute data to decide what to do.
Godlike.Host offers hosted Rust servers with its own game panel, SFTP access and free DDoS protection, if you would rather not host it yourself.
The configuration is short, but the API contract matters. The endpoint must identify the 64-bit Steam ID, return the expected reason and expiry fields, and represent permanent bans with an expiry value of zero or less. This guide explains the architecture, API requirements, hosted and self-hosted setup, verification, troubleshooting, and how this method differs from RCON-based ban lists.
As an Amazon Associate I earn from qualifying purchases.
Free tools Windows power users keep installed
One-click scans. No signup required.
What centralized banning does
Normal Rust bans are local to an individual server unless you distribute them by another mechanism. Centralized banning moves the ban decision to a web service shared by several Rust servers. Each connected server asks that service about a player when the player attempts to join. A ban recorded once in the shared database can therefore be recognized by every server configured to use the same endpoint.
The Rust server does not host the database itself. It acts as the client of a small web API. The API receives a SteamID64, looks up the corresponding record, and returns the fields Rust expects. This arrangement separates game-server administration from ban-data storage: you can update the list without editing every server’s local files, while each server keeps control of whether it participates by setting or removing the endpoint convar.
#1 Best Overall
- [Ultra-Lightweight Ear Buds Designed for Small Ears] Each earbud weighs only 3.7g and features a compact, ergonomic in-ear design made especially for small ears. Secure, low-profile, and comfortable for workouts, all-day wear or overnight sleeping.The ultra-slim profile sits flush in your ear with no hard edges poking or rubbing, so you can even sleep on your side without discomfort.
- [Immersive Stereo Sound with TOZO OrigX Technology] TOZO OrigX tuning delivers clear vocals, balanced mids, and natural stereo sound for music, podcasts, and videos.
- [Long Battery Life for Daily Use] Get up to 7 hours of playtime on a single charge, with up to 32 hours total using the charging case—ideal for workdays, commuting, and extended listening sessions.
- [Bluetooth 5.3 & Stable Connection] Bluetooth 5.3 provides fast pairing, stable wireless performance, and reduced dropouts as you move around home or office.
- [Deep Bass with Clear Vocals] High-performance drivers produce punchy bass while keeping vocals clean and detailed for everyday listening.
Centralized banning can also carry mute information. The API response includes an isMute flag, so a shared service can communicate a mute as well as a connection ban. Facepunch’s documentation notes that mutes can be shared across servers through this API.
What you need before configuring Rust
- A reachable API: It must be available over HTTP or HTTPS from the machine running the Rust server. Facepunch supplies the API specification, not an operating ban-server implementation.
- A ban data source: This can be an API and database you operate, or an implementation provided by your host. Some hosts require access to a private ban database before enabling the feature.
- The server’s configuration access: Hosted servers normally expose
server.cfgand a console in their control panel. A self-hosted installation requires access to its configuration files and server console. - 64-bit Steam IDs: The lookup key is the joining player’s SteamID64, not a display name or a shorter account identifier.
- A test plan: Have an approved test record or the API project’s documented test route available before relying on the list for real moderation.
Use HTTPS when the service is reachable over the public internet. It protects the request path and response from being modified in transit. Keep administrative operations on the ban database authenticated and separate from the read request Rust performs for each joining player.
Choose where the ban API will run
There are two supported deployment choices. The Rust configuration is the same either way; the difference is who operates the API and its data.
| Choice | Who operates the service | What you must arrange | Best fit |
|---|---|---|---|
| Self-hosted API | You or your technical team | Application, database, HTTPS endpoint, backups, monitoring, and updates | Communities that need control over data, policy, and server count |
| Host-provided API | Your game-server provider or its integration partner | Access to the provider’s private ban database and the endpoint it gives you | Administrators who want less infrastructure to maintain |
| Open-source implementation | You, using a community project such as RustCentralBanServer | Deployment of the project, its storage, and a public or privately routed URL | Teams comfortable operating an existing codebase rather than building an API from scratch |
Facepunch’s Centralized Banning wiki describes the API as relatively simple to implement but explicitly says that Facepunch does not provide an implementation. An open-source project such as RustCentralBanServer can supply a starting point, while a host’s integration may already include storage and an administration interface. Confirm what each option actually supplies: an endpoint alone is not the same as a maintained ban database.
Rank #2
- 【IP68 Waterproof Multifunctinal Smart Watch】Torjalph fitness activity tracker smart watch is IP68 waterproof technology ,you can wear it when swimming,handwashing,it's rain-proof which means that you perform multiple exercise modes outside without worrying about sweat or rain corroding your fitness smart watch,and this watch equipped with a 230 mAh large capacity battery magnetic charging ,and this sports activity tracker watch can be used 5-7 days If fully charged.
- 【Larger 1.83'' Full Screen Watch & Multi-dial Selection】1.83 inch full HD color touch screen smart watch for men / women provides excellent 240*284 resolution image quality ,This Bluetooth smart watch offers a better touch experience and remarkable immersion and ,more than 200 watch faces for you to choose from App"Da Fit ", you can change the dial style according to your mood to wear keeping the world on your wrist
- 【Accurate Activity Tracker Smart Watch 】sports watch activity tracker uses sweat and dust resistant breathable silicone strap, our Fitness Tracker Smart Watch for Android iOS Phones supports 12 sports modes,walking,running,bicycle,swimming,badminton,basketball,football,rope skipping. This bluetooth calls smart watch for men women is lightweight and stylish, bringing more convenient and relaxing sports experience while also providing more protection.
- 【Your 24 Hour Personal Daily Health Monitor】Fitness watch for women men full touch screen IP67 waterproof bluetooth smartwatch for Android iOS Phones with heart rate blood pressure monitor multifunction Andriod smart watch with steps counter sleep monitor sports fitness watch, monitoring blood oxygen saturation allows you to understand your physical condition in real time to track fitness progress ,to know your health status in time.
- 【More Functions Bluetooth Call Smart Watch】This fitness activity smart watch full screen for iPhone and Android phones includes a bunch of new features including:The bluetooth smart watch can hang up the phone, receive and display WhatsAPP /Text /Facebook /Twitter /Messenger reminder.Support sedentary reminder, alarm clock, stopwatch, timer,weather information,music control, remote camera control compatible with Android 5.0 and above or iOS 9.0 and above smartphones.
Understand the endpoint and response contract
Base URL and lookup path
Set the convar to the API’s base URL, for example:
server.bansServerEndpoint "https://domain.tld/api/rustBans/"For a joining player, Rust appends the player’s SteamID64 to the route, producing a request in this form:
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
GET /api/rustBans/{steamID64}If the base URL already includes the /api/rustBans/ path, do not append that path a second time in your configuration. Use the exact URL supplied by your API operator and preserve the trailing path expected by that implementation.
Required response information
The Facepunch wiki specifies these response fields:
Rank #3
- [Low Noise High Fidelity] New bee guitar cord with 22AWG oxygen-free-copper center conductors provides enhanced signal transfer, the PVC insulation material and the high-density stranded copper double shield provide noise rejection for quiet operation
- [Ideal for Choice] New bee 1/4 straight and right angle metal connectors, ensures a secure connection in any instrument, pedal, or amp jack. L shape great fro on stage guitar stands
- [Wide Compatible] Suitable for mixer, power amplifier, microphone, effector, decoder, equalizer, electoronic organ, electric guitar, electric bass and other electronic equipments. Widely used in the installation of smart home, karaoke speaker, professional stage audio, etc
- [Easy Disassemble] Making incidental repairs quick and easy! Very nice, flexible cable
- [Dont Hesite to Order] 24 hours customer services and professional technology team are standing by
| Field | Purpose | Important detail |
|---|---|---|
steamId |
The banned player’s SteamID64 | Use the 64-bit Steam identifier associated with the lookup. |
reason |
Explanation shown to the player | Write a clear moderation reason; avoid putting private staff notes in a player-visible value. |
expiry |
Ban end time | Unix timestamp. A value less than or equal to zero means the ban is permanent. |
isMute |
Identifies a mute record | Allows mute information to be shared across servers through the centralized API. |
Unix timestamps represent a point in time rather than a duration. Store and generate the value in the format your API implementation expects, and ensure that the server and API agree on whether the timestamp is expressed in seconds. A timestamp accidentally supplied in milliseconds can appear far in the future and behave like a permanent ban.
The field names above come from the Facepunch wiki’s documented contract. Because the live page and individual implementations can change, compare your API’s output with the current wiki and the README for the implementation you deploy before production use. Do not rename fields for convenience or return a display name in place of steamId.
Illustrative response shape
The following is an example of the field shape, not a universal response that you should copy without checking your implementation:
{
"steamId": "76561198000000000",
"reason": "Repeated chat harassment",
"expiry": 1790000000,
"isMute": false
}For a permanent record, set expiry to a value of zero or below. For a mute, the implementation should set isMute according to its documented behavior and provide the other fields required by its schema. The documentation does not define a single universal JSON example for every non-banned response, so test the clear-result behavior supplied by your API rather than assuming an empty object, a particular status code, or a particular message.
Rank #4
- Digital Family Calendar: BSIMB digital calendar wall touch screen puts an end to your chaotic life. Designed for busy families, the digital calendar keeps you organised and in step with your family. Assign different colours and tasks to each family member to make family scheduling easier and more intuitive.
- Easy Setup and Auto-Sync: Plug in, connect to WLAN and auto-syn your electric calendar in minutes. Digital wall calendar compatible with Google calendar, iCloud calendar, Outlook calendar, Cozi calendar and Yahoo calendar. Add events directly on the device or through the ecalendar app. Electronic calendar stays current whether you're at work or traveling—no manual updates needed.
- All-In-One Home Assistant: Smart calendar builds habits and encourage independence with personalised chores. Display daily meal plan to reduce the daily ‘What's for dinner?’ stress. To-do lists keep track of everything you want. Turning chores into valuable achievements with stars and rewards, making life easier and more enjoyable.
- Manage Anytime Anywhere: BSIMB electronic calendar for family stay connected with the powerful ecalendar app. Access and manage your digital wall calendar anytime, anywhere with free features like stars & rewards, photo screensaver, chore charts, meals plans, to-do lists etc. Electronic planner paid features like Magic Import tailor advanced tools for users with special needs.
- Stay in Touch with Loved Ones: Share photos or videos from your phone to electronic wall calendar with app, instantly update your life moment, and keep in touch with your family, especially those who are far away; you can also surprise your smart calendar digital wall by sending him a wish card; it's also great for keeping tech-illiterate elders in touch with the youngsters.
Configure a hosted Rust server
Control panels vary, but the reliable sequence is to place the convar in the server configuration and then reload that configuration through the console. A provider’s documentation may use slightly different menu names.
- Obtain the endpoint from the API operator. Confirm that it is the base URL for Rust centralized banning, not an RCON address or a web page. An example format is
https://domain.tld/api/rustBans/. - Stop the server if your host requires it for file edits. Some panels lock configuration while the process is running; others allow a safe edit. Follow the panel’s stated procedure.
- Open the server configuration editor. Add one line to
server.cfg:
server.bansServerEndpoint "https://domain.tld/api/rustBans/"- Save the file. Check that quotation marks are paired and that the URL has no invisible spaces or copied punctuation.
- Use the server console. Run
writecfg, thenreadcfg, as described in hosted-server guidance. These commands write the active settings and reload the configuration so the convar takes effect. - Restart if the panel or provider requires it. A restart is also a useful way to confirm that the setting persists rather than existing only in the current console session.
- Record the final value. Reopen
server.cfgor inspect the loaded convars using the tools your host exposes. This catches panels that regenerate configuration files from a separate template.
If your provider supplies the ban database, ask which records are shared among your servers and how staff add, expire, or remove them. The endpoint connection alone does not tell you the provider’s moderation workflow.
Configure a self-hosted Rust server
On a server you operate directly, add the convar to the configuration used at startup and preserve it with the server’s configuration command.
- Deploy or obtain an API implementation and make its base URL reachable from the Rust host.
- Verify the API’s database contains at least one controlled test record and that you know the associated SteamID64.
- Add the convar to the Rust server configuration:
server.bansServerEndpoint "https://domain.tld/api/rustBans/"- Save the active configuration with
server.writecfg. - Restart or reload the server according to your installation’s normal procedure, then confirm that the setting remains present.
- Keep the API and Rust server clocks synchronized. Expiry decisions depend on Unix time, so a badly skewed clock can make a temporary ban appear active for too long or end early.
The exact console sequence for self-hosted installations can vary with the way you launch and manage the server. The documented self-hosted instruction is to save the convar with server.writecfg; verify the resulting file and your startup scripts rather than assuming that a panel-oriented writecfg/readcfg sequence applies unchanged.
Test the connection before using it for moderation
Test the API independently
RustCentralBanServer’s README suggests requesting:
GET /api/rustBans/testUse the complete base host in your HTTP client, for example:
curl -i "https://domain.tld/api/rustBans/test"The purpose of this request is to establish that DNS, TLS, routing, and the application are reachable. The README does not make this route a substitute for a real SteamID lookup, so continue with an actual test record after the route responds.
Test a known record
- Create or select a temporary ban record for an account you control. Use a short expiry and an unmistakable reason.
- Request the corresponding path with that account’s SteamID64.
- Check that the response contains the documented
steamId,reason,expiry, andisMutefields and that the timestamp has the intended meaning. - Join the Rust server with the test account and confirm that the player-facing result matches the record.
- Remove the test record or let it expire, then repeat the lookup and join test to verify the clear path.
Never test with a real moderator’s account unless everyone involved understands that the account may be refused at the join screen. Keep a record of the test SteamID so a temporary ban cannot be mistaken for a production moderation action.
Troubleshoot common failures
The server never appears to query the API
- Confirm the convar is spelled exactly
server.bansServerEndpoint, including capitalization. - Check that the line is in the configuration file actually loaded by this server instance. Hosting panels often have separate files for different identities or worlds.
- Ensure the value is the API base URL, not the
/testroute and not an administrative dashboard URL. - Save and reload the configuration, then restart if necessary. A line added to an unused file has no effect.
Requests fail before reaching the application
- From the Rust host, resolve the API hostname and make a direct HTTPS request with an HTTP client.
- Inspect TLS certificate validity, firewall rules, reverse-proxy routing, and outbound firewall policy.
- Check whether the API is bound only to localhost. Rust must be able to reach the interface and port where the service listens.
- Look at the API access log while a test lookup runs. No incoming request points to URL, DNS, network, or configuration trouble rather than a ban-data problem.
Known banned players are admitted
- Compare the requested path with
/api/rustBans/{steamID64}. A missing or altered SteamID segment prevents the correct lookup. - Inspect the response field names and types. In particular, verify that
steamIdis the 64-bit value and thatexpiryis a Unix timestamp, not a formatted date or a duration in minutes. - Check the timestamp against the current UTC time. A value at or below zero means permanent; a value in the past is no longer active.
- Confirm that the test account exists in the database used by this endpoint. Multiple environments can make a development list look correct while production reads another database.
Players are refused unexpectedly
- Inspect the API record for an old permanent value or an expiry accidentally generated in milliseconds.
- Verify that the response belongs to the requested SteamID and that an account identifier was not copied incorrectly.
- Review recent database edits and staff actions. Keep the player-facing
reasonspecific enough to identify the relevant moderation decision. - Temporarily remove the endpoint from a test server, not from production, to determine whether the refusal originates in centralized data or another local ban mechanism.
Mutes do not behave as expected
- Confirm that the API returns
isMutewith the value required by its implementation. - Check whether the record is a mute or a connection ban. They are different moderation outcomes even though both can travel through the centralized API.
- Test on every server that should share the mute and verify that each one points to the same endpoint and database.
The setting disappears after a restart
- Run the appropriate configuration-save command and inspect the generated file.
- Check whether the hosting panel regenerates
server.cfgfrom a template or startup variable. - Place the convar in the provider’s persistent configuration field if one exists, then reload and verify again.
Centralized banning versus RCON ban lists
Do not confuse the endpoint-based feature with RustTools’ “Ban Lists” documentation. That system pushes banid RCON commands to subscribed servers. It does not use server.bansServerEndpoint and does not follow the centralized API response contract.
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minuteWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstall| Characteristic | Centralized API | RCON ban-list distribution |
|---|---|---|
| How a server learns about a ban | It queries the web endpoint when a player joins. | A service sends banid commands to subscribed servers. |
| Configuration on the Rust server | server.bansServerEndpoint |
RCON access and the distributor’s subscription settings |
| Data location | Shared API and its ban database | Local bans created by commands on each subscribed server |
| Mute field | The API contract includes isMute. |
RCON ban pushes are not the same mute-capable contract. |
| Operational dependency | The endpoint must be reachable during the join check. | The distributor must have RCON connectivity when it pushes changes. |
Choose one distribution model for a given server unless you have a deliberate reason to operate both. Running two systems can produce conflicting records, duplicate moderation messages, and uncertainty about which service must be edited to lift a ban.
Operating the system safely
- Back up the ban database. A centralized list becomes critical infrastructure when several servers depend on it. Keep tested backups and document how to restore them.
- Limit write access. Staff who can add or remove records should use authenticated administration tools. The public lookup endpoint should expose only the data required for the join decision.
- Keep reasons player-safe. The
reasonvalue is shown to the player, so do not include internal evidence, personal information, or staff-only commentary. - Use consistent expiry policy. Define whether your team records temporary bans in UTC-based Unix time and how permanent bans are represented. The API’s rule is that zero or a negative expiry is permanent.
- Monitor availability. Watch API uptime, certificate expiry, database errors, and request latency. A join-time dependency deserves an alert before players report failures.
- Document ownership. Write down the endpoint owner, database location, backup schedule, staff contacts, and the procedure for emergency removal of a mistaken record.
- Stage changes. Point a test Rust server at the API first, exercise ban, expiry, mute, and clear cases, and only then update the public servers.
Practical configuration checklist
- Choose a self-hosted, host-provided, or open-source API implementation.
- Confirm that the API follows the documented route
/api/rustBans/{steamID64}and response fields. - Put the service behind a reachable HTTP or HTTPS URL; prefer HTTPS for internet-facing deployments.
- Add
server.bansServerEndpointwith the API base URL to the correct Rust configuration file. - On a hosted panel, save the file and run
writecfgfollowed byreadcfgas the provider documents. - On a self-hosted installation, save the setting with
server.writecfgand verify the generated configuration. - Call the implementation’s test route when available, then perform a real SteamID lookup.
- Test a temporary ban, a permanent ban, an expiry, a mute, and a cleared record on a non-production server.
- Document who maintains the API and how staff correct a mistaken ban.
What success looks like
A successful connection has a simple observable chain: the Rust server retains the convar after reload; the API receives a request containing the joining player’s SteamID64; the response uses the documented fields; and the resulting ban, mute, expiry, or admission matches the record in the shared database. If any link fails, test that link independently instead of changing several components at once.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
