Set Up Guardian on Unraid for Plex Access Control
Install Guardian on Unraid with Docker Compose, verify the web UI on port 3000, then reach it remotely over an HTTP tunnel with Localtonet.
In this article 14 sections
Run Guardian beside Plex on Unraid, and decide deliberately whether its web UI should ever be public
Guardian is an access-control layer for Plex Media Server. It lets you approve or block devices, enforce per-user schedules and IP rules, cap concurrent streams, and stop sessions that break the rules. This guide covers installing it on Unraid with Docker Compose, wiring it to Plex across Docker networks, testing rules, backing up its data and updating it. Only after a security gate do we show how to publish the web UI with a Localtonet HTTP tunnel, and how to keep that tunnel healthy on an Unraid server. We also say exactly which details we could not read in the public project material, so you are never left guessing which parts are verified.
📋 What's in this guide
What Guardian does and why Unraid is a good home for it

Plex Media Server decides who can sign in, but many owners want finer control over how a shared library is actually used. Guardian sits alongside Plex as an access-control layer. According to the project description, it can approve or block devices, enforce per-user schedules and IP rules, cap the number of concurrent streams, and stop sessions that break the rules. In practice, a new device that signs in does not automatically get to stream until you have decided about it, and a user who exceeds a limit can have a session ended.
Unraid suits this kind of service. Plex often already runs on the same machine, Docker is built in, and the box is on all the time. Running Guardian there keeps the control plane next to the thing it controls. The project documents a Docker Compose installation and describes creating a Compose stack on Unraid, so this guide follows that path.
The public material we could read for this revision is the repository landing page and the v2.1.0 release notes. The landing page shows the project description, a history of 739 commits, and top-level folders including backend, docs, .github and .githooks. It did not include the text of the README, the contents of the docs folder, or the body of docker-compose.example.yml. We therefore do not reproduce an image name, environment variable names, volume paths or an authentication setting, because we cannot confirm them. Where that matters, this guide tells you what to look for, gives you a procedure that works regardless, and marks the gap plainly.
Guardian uses the PolyForm Noncommercial license, so describe it as self-hosted, source-available software rather than OSI-approved open source, and read the license before any commercial use. The most recent release we could see is v2.1.0 (published by GitHub Actions on 26 Oct), which adds automatic releases, database migrations and frontend linting, fixes the LOOPBACK constant to use a regex, and bumps frontend and backend dependencies. The release notes link a full changelog from v2.0.1, so earlier tags exist. A history of 739 commits and automated releases point to a project with substantial development behind it. Check the Releases page for any tag newer than v2.1.0 before you install.
Prerequisites
Two requirements come from the project itself: a reachable Plex Media Server and a Plex token. The Docker-based install adds the rest.
A reachable Plex Media Server
Guardian controls access to a Plex Media Server, so it needs one it can reach over the network. On Unraid, Plex is commonly another container on the same machine. If Plex runs elsewhere, confirm that your Unraid server can reach that host on the Plex port before you continue. The networking section below shows how to test this properly.
A Plex token
The token authorizes access to your Plex account and server, so treat it like a password. Plex documents its own method for finding it: open any media item in Plex Web, choose Get Info, then View XML, and read the X-Plex-Token value in the address of the XML page. Because Plex can change its interface, follow Plex's own current instructions if the menus differ. Store the token in a password manager, and never paste it into a public post, screenshot or shared chat.
Docker and Compose on the Unraid host
You need a working Docker service and a way to run Compose stacks. Unraid users typically use a Compose manager plugin that provides a Stacks section, or run docker compose from the terminal if the Compose plugin for Docker is present. Menu names vary with your Unraid version and plugin, so we describe the flow rather than promise specific labels.
A free port 3000 and a place for data
The web UI is documented on port 3000. If another container already publishes host port 3000, either stop it or remap Guardian's host port, and remember the new value because it becomes your tunnel target later. Also decide where persistent data will live. On Unraid the convention is a per-application folder under /mnt/user/appdata, for example /mnt/user/appdata/guardian, so that the data sits on your cache pool or array and is covered by your normal backup routine.
Unraid container networking: reaching Plex from inside Guardian
Most failed first runs are not Guardian problems. They are Docker networking problems. A container has its own network namespace, so the name localhost and the address 127.0.0.1 inside the Guardian container mean the Guardian container itself, not your Unraid server and not the Plex container. If you enter http://localhost:32400 as the Plex address, Guardian looks for Plex inside its own container and finds nothing.
LAN browser or phone
|
v http://UNRAID-IP:3000 (only this port is published)
+------------------ Unraid host (UNRAID-IP) -------------------+
| |
| Guardian container --- http://UNRAID-IP:PLEX-PORT ---> |
| (web UI on 3000) |
| Plex container|
| (Plex's own port, 32400|
| by default) |
+--------------------------------------------------------------+
^
| outbound connection only
Localtonet client (see the tunnel sections) --> public HTTPS address
The diagram shows the trust boundary we recommend: Guardian's port 3000 is the only thing a tunnel ever targets, Plex keeps its own port, and nothing in this workflow publishes Plex through Localtonet.
Bridge networks and custom networks
A container on Unraid's default bridge network, or on the project network that Compose creates for a stack, reaches other services through the host. The reliable approach is to use the Unraid server's LAN IP address and the port Plex publishes. Containers attached to the same user-defined Docker network can also reach each other by container name, but that only works if Guardian and Plex share that network, and it is an extra moving part you do not need. Using the host IP works whether Plex is on the bridge, on a custom network, or on the host network.
| Where Plex runs | Address to give Guardian | Note |
|---|---|---|
| Container on the default bridge with its port published | http://UNRAID-IP:PLEX-PORT |
Plex's default port is 32400 unless you changed the mapping |
| Container in host network mode | http://UNRAID-IP:32400 |
Plex binds directly to the host, so the host IP works |
| Container with its own IP on a custom network | That container's IP and port | Depending on your Unraid network settings, the host or other containers may not reach a container that has its own IP, so test it before trusting it |
| Plex on a different machine | That machine's LAN IP and Plex port | Confirm your Unraid server can reach it and that no firewall blocks the port |
Test reachability before you configure anything
From the Unraid terminal, Plex answers an unauthenticated identity request. A short XML response means the host can reach Plex.
curl -i http://UNRAID-IP:32400/identity
After Guardian is running, repeat the test from inside its container if the image includes curl or wget. We cannot say whether it does, so if the command is missing, rely on the host-level test and the Guardian logs.
docker exec -it CONTAINER-NAME curl -i http://UNRAID-IP:32400/identity
Use docker ps to find the container name Compose assigned.
Install Guardian with Docker Compose on Unraid

The documented installation is short: take the example Compose file from the Guardian repository, save it as docker-compose.yml, and start the stack in the background. The example file is named docker-compose.example.yml and sits at the top level of the repository, which is maintained by HydroshieldMKII on GitHub.
Get the example Compose file
Download docker-compose.example.yml from the Guardian repository, ideally from the tag you intend to run so that it matches that release. Do not use a Compose file from a forum post or an unrelated tutorial, because image names and settings change between versions.
Save it as docker-compose.yml
Put the file in a dedicated folder such as /mnt/user/appdata/guardian and name it docker-compose.yml. With a Compose manager plugin, create a new stack, give it a name, and paste the file contents into the stack's Compose editor instead.
Adapt the file to your Unraid server
Walk through the checklist below line by line. Point every data volume at a folder under /mnt/user/appdata, resolve any port conflict on 3000, and fill in any value the file marks as yours to supply.
Start the stack
From the folder containing the file, run the command below. With a Compose manager plugin, use the stack's Compose Up action, which performs the same operation.
docker compose up -d
The -d flag detaches the containers so they keep running after you close the terminal. The first start pulls images, which takes longer on a slow connection.
What to check in the example file before you start
We could not read the body of the example file for this revision, so we will not print a version that might not match the repository. Instead, use this checklist, which applies to any Compose file and tells you what each part means on Unraid.
| Element in the file | What to confirm | Why it matters on Unraid |
|---|---|---|
image |
It names the Guardian image and a tag you chose, not an unrelated project | Pinning a release tag makes updates a deliberate decision rather than a surprise |
ports |
A mapping that exposes the web UI on 3000, in the form host:container | The host side is what you browse to and what a tunnel targets. Change only the host side if 3000 is taken |
volumes |
Any persistent data location, and whether it is a bind mount or a named volume | A bind mount under /mnt/user/appdata is easy to back up. A named volume lives inside Docker's storage and needs a different backup approach |
environment or env_file |
Every variable the file lists, and which ones are required | Secrets such as tokens must not end up in a shared file or a public repository |
restart |
A restart policy, if present | Without one, the container may stay stopped after a reboot. Add a policy such as unless-stopped yourself if the file lacks it |
networks |
Whether the file defines a custom network or relies on the default | It affects how Guardian reaches Plex, as described in the networking section |
The image name, the exact variable names, the data volume path and whether Plex details are supplied through the Compose file or through the web UI all come from files we could not read. The checklist above and the first-run steps below work without them. If the example file or the README contradicts anything here, the repository wins.
First run: connecting Guardian to Plex
With the stack running, open http://UNRAID-IP:3000 from another device on your network. Guardian needs two facts about your Plex server: where it is and the token that authorizes access. We could not confirm whether those are entered in the web UI on first launch, set through environment variables in the Compose file, or both. Look in both places: the first screen the UI shows you, and the environment section of your Compose file. Whichever one asks for them, enter the address in the form http://UNRAID-IP:PLEX-PORT as discussed in the networking section, and then the token.
If the Compose file expects the token as an environment variable, avoid pasting it into a file that is synced to a public Git repository or included in screenshots. A separate env file with restricted permissions is safer than inline values, provided the example file supports one.
Do not decide anything about authentication on the first run. Read the security section before you let the UI leave your LAN. Until then, keep Guardian reachable on your local network only.
Configuring rules: a safe order for devices, schedules, IP rules and stream caps
The project description names four kinds of control. The exact screens and labels are in the application, so this walkthrough gives the order that avoids locking out your own household. Change one control at a time and test each before adding the next.
Start with device approval
Device approval is the simplest control to reason about. Sign in to Plex from a known device and watch how Guardian lists it. Approve your own devices first. Then sign in from a second, unapproved test device and confirm that it is held until you decide. Only after this works should you rely on blocking.
Add a per-user schedule
Pick one test user and give them an allowed window that includes the current time. Confirm playback works, then move the window so it excludes the current time and confirm the session is refused or stopped. Check which time zone the rule uses by comparing the behavior with your wall clock, because the server's time zone is what typically matters.
Try an IP rule from an address you control
IP rules restrict a user by address. Test first with an address you can trigger on demand, for example your own phone on mobile data compared with your home Wi-Fi. Confirm that an allowed address streams and a disallowed one does not, before applying the rule to anyone else.
Set a concurrent stream cap
Set the cap to 1 for the test user, start a stream on one device, then try a second device. The second session should be refused or stopped. Raise the cap to the number you actually want only after you see it enforced.
Keep an owner escape hatch
Before rolling rules out to everyone, confirm your own account and devices are not caught by a rule you wrote for someone else. Keep your admin access to the Guardian UI over the LAN, so a mistake cannot lock you out of the tool you need to fix it.
Guardian's stated purpose includes stopping sessions that break the rules, which means a rule can interrupt playback that is already in progress. Tell your users when you begin enforcing, and start with generous settings. We have not verified how quickly Guardian detects a violation, so measure it on your own server during these tests rather than assuming an instant cut-off.
Verify the installation locally

Prove that the service works on your LAN before any tunnel exists. If it fails locally, a tunnel only exposes a broken page. Run these checks in order from the folder containing your Compose file.
1. Confirm the container is running
docker compose ps
Every Guardian service should show a running state. A service that keeps restarting or has exited points to a configuration problem, and the logs will tell you more.
2. Read the logs
docker compose logs --tail=100
Look for startup errors, failed connections to Plex, or messages about missing configuration. Redact tokens before sharing any log output.
3. Check that port 3000 answers
curl -I http://localhost:3000
Run this from the Unraid terminal, where localhost correctly means the host. Any HTTP response line means something is listening. Then open http://UNRAID-IP:3000 from another device on your network and confirm the interface loads.
4. Confirm Guardian can see Plex
After supplying the Plex connection details, start a short playback from a test device and check that Guardian notices the device or session. Keep this first test simple: one account, one device, and no unusual restrictions.
| Check | What a good result looks like | If it fails |
|---|---|---|
| Container state | All Guardian services running | Read the logs and re-check the Compose file |
| Port 3000 on the host | An HTTP response from curl and a loading web UI | Check for a port conflict or a changed port mapping |
| Plex connection | Guardian shows information from your Plex server | Verify the Plex address uses the host IP, the Plex port, and a valid token |
| Rule behavior | A test session is allowed or blocked as configured | Simplify the rules and test with one user and one device |
Backup and restore
Guardian holds your rules, device decisions and connection settings, and the v2.1.0 notes mention database migrations, which tells us the application keeps structured data that can change shape between versions. We could not confirm the exact file or folder it uses. That does not block you from backing it up: whatever your Compose file maps as a persistent volume is the data to protect. This is why the install checklist asks you to identify it.
Back up
If the data is a bind mount under appdata, stop the stack first so no write is half finished, archive the folder, then start again. Replace the path with the one from your Compose file.
cd /mnt/user/appdata/guardian
docker compose stop
tar -czf /mnt/user/backups/guardian-$(date +%F).tar.gz /mnt/user/appdata/guardian
docker compose start
The archive includes your Compose file and any env file, which may contain the Plex token. Store backups where only you can read them. If the file uses a named Docker volume rather than a bind mount, the data is inside Docker's storage, and the simplest dependable fix is to change the mapping to a bind mount under appdata before you have data worth losing.
Restore
cd /mnt/user/appdata/guardian
docker compose down
tar -xzf /mnt/user/backups/guardian-YYYY-MM-DD.tar.gz -C /
docker compose up -d
Restore onto the same Guardian version you backed up from where possible, because newer versions may migrate the data forward. After restoring, open the UI and confirm your devices and rules are present before you rely on enforcement.
docker compose down keeps your data, but adding volume-removal flags deletes it. Take a backup before any command that you have not run before.
Routine operation and updates
Day-to-day work is standard Compose housekeeping, run from the folder containing your docker-compose.yml.
docker compose stop
docker compose start
docker compose restart
docker compose down
stop and start pause and resume the containers, restart does both, and down removes the containers and the stack's network while leaving bind-mounted data in place.
Updating Guardian
We could not read the update instructions in the project README, so what follows is the general Compose update pattern, not a Guardian-specific procedure. Before you rely on it, read the release notes for the target tag, because the v2.1.0 notes mention database migrations and we have not confirmed whether they run automatically at startup.
Read the release notes
Open the release for the tag you want on GitHub and check for changes that affect your rules, data or Compose file.
Back up the data
Use the backup procedure above, so you can roll back if a migration misbehaves.
Update the tag and pull
If you pinned a tag in the image line, change it to the new one, then pull the new image.
Recreate and verify
Recreate the containers, read the logs for migration messages, and repeat the local verification checks.
docker compose pull
docker compose up -d
docker compose logs --tail=100
Security go/no-go before you expose the web UI

Guardian is a control surface. Whoever can use its web UI can potentially change who is allowed to watch your media and may be able to see device and user information. Publishing it is a security decision.
We checked the public material available to us and could not confirm whether Guardian requires administrators to sign in, whether authentication is enabled by default, or how to enable it. The README and docs folder that would answer this were not readable to us, so we will not guess. Until you have personally confirmed that a login is enforced, treat the answer as no-go: keep Guardian on your LAN and do not start a public tunnel.
How to reach a go decision
- Read the authentication section of the Guardian README and the
docsfolder for your installed tag, and follow whatever it says about enabling and configuring login. - Open
http://UNRAID-IP:3000in a private browser window with no saved sessions. You should be asked to sign in before seeing any device, user or rule data. - Run
curl -i http://UNRAID-IP:3000from a machine with no session and confirm you get a login page or an authorization error, not management data. - Use a strong, unique password if a password is involved, and do not reuse your Plex password.
| What you observe | Decision | Next action |
|---|---|---|
| Login is required before any data is shown, and you set a strong credential | Go, with care | Create the tunnel, test from outside, and stop it when not needed |
| Management screens load without signing in | No-go | Keep it on the LAN, or enable authentication if the docs describe how, then retest |
| You cannot tell either way | No-go | Treat it as unprotected, and keep it off the internet until you can tell |
If you only need occasional remote administration and cannot confirm authentication, consider reaching your home network privately instead of publishing a page. Localtonet offers a VPN Manager for a private mesh network, described in our VPN Manager overview. That is a separate feature from tunneling, and it keeps the Guardian page off the public internet.
Reach Guardian remotely with a Localtonet HTTP tunnel

Only continue if the security section gave you a go. Everything so far runs on your LAN, which is enough if you manage Guardian from home. To approve a device while traveling or check sessions from your phone, you need a way in from outside. Opening a port on your router exposes your network edge and does not work behind carrier-grade NAT. With Localtonet, the client on your network makes an outbound connection to a Localtonet relay server and the tunnel provides a public HTTPS address, with no inbound router port forwarding, firewall changes, VPN setup or public IP address.
Guardian's web UI is plain HTTP on port 3000, which is the shape an HTTP tunnel is built for. The tunnel is available only while the selected client is connected and the tunnel is running, and creating a tunnel does not start it.
Choose where the Localtonet client runs
The client must run on a device from which Guardian is reachable, and the local target you enter is resolved from that device's point of view.
- On the Unraid host itself: if Guardian publishes host port 3000, the target
127.0.0.1with port 3000 works, because the client and the published port are on the same host. The Unraid LAN IP with port 3000 works too. - In a Docker container on Unraid:
127.0.0.1then refers to the Localtonet container itself, so use the Unraid LAN IP and port 3000. - On another always-on machine: use the Unraid server's LAN IP and port 3000, and first confirm with
curlfrom that machine that the port answers.
Create and start the tunnel
Follow the official Localtonet HTTP tunnel documentation for the current dashboard layout, since labels can change. The sequence below matches the documented flow for our web tunnels.
Install and run the Localtonet client
Install the Localtonet app for your operating system on the device chosen above. Download and install instructions are on our website.
Open the HTTP tunnel page
In the dashboard, go to the HTTP tunnel page and start a new tunnel.
Select the Process Type
Choose Random Sub Domain, Custom Sub Domain or Custom Domain. All three serve the same content at a public HTTPS address. Random Sub Domain is the simplest choice for a first test.
Select the AuthToken and server
Pick the AuthToken of the device running the client, and one of the servers offered in the dashboard. Tokens are device-specific, so keep yours private and never paste it into screenshots or tickets.
Enter the local IP address and port 3000
Set the local target to the address that works from the client device, as explained above, with port 3000. If you remapped the host port in your Compose file, use that port instead.
Press Start
The tunnel does not run until you start it. After it starts, the dashboard shows the public HTTPS address. Open it from a phone on mobile data, confirm the login you verified earlier appears, and stop or delete the tunnel when you no longer need it.
Custom Sub Domain and Custom Domain are easier to remember, but custom-domain DNS requirements must be checked against the current Localtonet documentation before you configure them, and we do not give record values here for that reason.
| Setting | Value for Guardian | Note |
|---|---|---|
| Tunnel type | HTTP | The UI is served over HTTP locally and published at a public HTTPS address |
| Process Type | Random Sub Domain, Custom Sub Domain or Custom Domain | Start with a random subdomain while testing |
| Local target | IP address and port 3000, valid from the client device | Use your remapped port if you changed the Compose mapping |
| Lifecycle | Create, then Start | Works only while the client is connected and the tunnel is running |
Do you need to tunnel Plex itself?
No. This tunnel publishes Guardian's web UI on port 3000 and nothing else. It does not carry Plex streams, and Guardian does not route Plex playback through Localtonet. Your Plex server's remote access is a separate topic and decision, and we do not cover Plex remote streaming over Localtonet in this guide.
Keeping the Localtonet client and tunnel running on Unraid
A tunnel is only as reliable as the client behind it. On a server that reboots for updates, array changes or power events, plan for the client to come back without you.
Client persistence
The public address works only while the selected client is connected. If the Unraid host reboots or the client process stops, the tunnel goes offline until the client runs again. We do not publish a startup command here because the install instructions for your operating system, in our documentation, are the correct source for how the client is installed and launched. What we can say is the Unraid side of the problem: arrange for the client to start with the server. Unraid users commonly do this with a startup script, for instance through the User Scripts plugin set to run when the array starts, or by running the client in a container with a restart policy such as unless-stopped. Either way, test it by rebooting during a quiet moment.
Restart behavior and what to check
After a reboot, do not assume the tunnel is live. Open the dashboard and check that the device shows as connected and the tunnel shows as running. If the client is back but the tunnel is stopped, press Start. We have not verified a guarantee that a tunnel resumes on its own after the client reconnects, so confirm it on your own setup and write down the result.
Also remember the dependency order. The tunnel can only forward to Guardian once Guardian is up, so make sure the Guardian stack starts with the array as well. If the tunnel starts first, requests will fail until Guardian answers on port 3000.
Get notified when it drops
Localtonet has a platform-wide webhook that fires when a token or tunnel in a selected Token Group changes to Connected or Disconnected. It posts a JSON body containing the tunnel id or auth token, the action date, the type (Token or Tunnel) and the status. Pointing that at a notification service tells you quickly when your Unraid client has gone offline. Setup details are in the Localtonet webhook documentation.
Stop and delete deliberately
If you only manage Guardian remotely now and then, stop the tunnel when you finish, and start it only when needed. A stopped tunnel serves nothing, which is the simplest way to shrink exposure.
Troubleshooting
Problems fall into three groups: the container does not run, the container runs but cannot talk to Plex, or the local service works but the tunnel does not. Diagnose them in that order and always test the layer below before blaming the layer above.
| Symptom | Likely cause | What to do |
|---|---|---|
| Stack will not start or keeps restarting | A configuration, volume or port problem | Run docker compose logs --tail=100, check for a port 3000 conflict, and re-read the Compose file |
| Web UI does not load on the LAN | Wrong IP, wrong host port, or container not running | Run docker compose ps and curl -I http://localhost:3000 on the Unraid terminal |
| Guardian cannot see Plex | Plex address entered as localhost, wrong port, or an invalid token |
Use the host IP and Plex port, confirm curl -i http://UNRAID-IP:32400/identity works, and re-check the token |
| Settings vanish after recreating the container | Data was not stored on a persistent volume | Map a bind mount under appdata, restore from a backup, and re-verify |
| Tunnel created but the public address fails | Tunnel not started, client disconnected, or wrong local target | Press Start, confirm the client is connected, and check the target from the client device |
| Tunnel target works on Unraid but not from the client | Client runs in a container or on another machine, so 127.0.0.1 is wrong or unreachable |
Use the Unraid LAN IP and port 3000, and test with curl from the client's environment |
| Tunnel worked, then stopped after a reboot | The client did not start with the server, or the tunnel was left stopped | Add startup for the client, check the dashboard, and press Start if needed |
| Rules do not seem to apply | Rule too broad or conflicting, or testing from the wrong address or time zone | Simplify to one user and one device, then add controls one at a time |
When you ask for help, share the Compose file with tokens removed, the relevant log lines, your Unraid version and the Guardian tag you run. Do not post your Plex token or your Localtonet auth token.
Frequently asked questions
How do I install Guardian on Unraid?
Download docker-compose.example.yml from the Guardian repository, save it as docker-compose.yml in a folder under /mnt/user/appdata, adapt its ports and volumes to your server, and run docker compose up -d. The project also describes creating a Compose stack on Unraid, which you can do through a Compose manager plugin by pasting the same file and using Compose Up. You need a reachable Plex Media Server and a Plex token.
Which port does the Guardian web UI use?
Port 3000. That is the port to browse to on your LAN and the port to use as the local target of a Localtonet HTTP tunnel. If you changed the published host port in your Compose file, use your own value instead.
What address should I give Guardian for Plex when both run on Unraid?
Use the Unraid server's LAN IP and the port Plex publishes, for example http://UNRAID-IP:32400 with Plex's default port. Do not use localhost or 127.0.0.1, because inside the Guardian container those refer to the Guardian container itself.
Is it safe to publish the Guardian admin interface through a tunnel?
Only if a login is enforced. We could not confirm Guardian's authentication from the material available to us, so our recommendation is no-go until you verify it yourself in a private browser window and with curl, following the steps in the security section. If management screens load without signing in, keep Guardian on your LAN.
Do I need to open a port on my router to reach Guardian remotely?
No. The Localtonet client makes an outbound connection to a relay server, so the tunnel needs no inbound router port forwarding, firewall changes, VPN or public IP address. The tunnel works only while the client is connected and the tunnel is started.
Should the Localtonet target be 127.0.0.1 or the Unraid IP?
It depends on where the client runs. On the Unraid host itself with port 3000 published, 127.0.0.1 works. If the client runs in a container or on another machine, use the Unraid LAN IP with port 3000, because 127.0.0.1 would point at the client's own environment.
Does this tunnel also give remote access to Plex streaming?
No. The tunnel described here publishes only the Guardian web UI on port 3000. Plex streams do not travel through it, and Plex's own remote access is configured separately.
Is Guardian open source, and what is the latest version?
Guardian uses the PolyForm Noncommercial license, which makes it source-available and self-hosted but not OSI-approved open source, so read the license before commercial use. The newest release we could see is v2.1.0, published on 26 Oct. Check the Releases page for anything newer before you install.
Start with Localtonet
Get Guardian running on your Unraid server, confirm that its login works on port 3000, and only then create an HTTP tunnel to manage it remotely. Create a free account to try it.
Get Started Free →Corrections & updates
Substantive changes approved by the Localtonet editorial team are listed transparently below.
Localtonet is a secure multi-protocol tunneling and proxy platform designed to expose localhost, devices, private services, and AI agents to the public internet supporting HTTP/HTTPS tunnels, TCP/UDP forwarding, mobile proxy infrastructure, file server publishing, latency-optimized game connectivity, and developer-ready AI agent endpoint exposure from a single unified control plane.