Skip to content

OpenAList Docker Setup and Secure Remote Access

Install OpenAList with Docker, find the admin password, verify it on port 5244, then reach the web UI remotely over an HTTP tunnel with Localtonet.

Summary in your language
In this article 14 sections
Self-Hosting · OpenAList Docker Setup · Localtonet · 2026

Run a self-hosted file listing service in one container, then reach it from anywhere over HTTPS

OpenAList is a community-driven fork of Alist (based on v3.45.0) that puts a web-based file listing and management layer over local and remote storage. This guide installs it with Docker, covers binary and source routes, handles the admin password, verifies the service locally and then publishes it with a Localtonet HTTP tunnel, with no router port forwarding. We are explicit about which OpenAList details we could re-confirm and which we could not, and we give you commands that let you check the unconfirmed ones on your own machine in a few seconds.

🔒 Admin password handling and safe exposure 🌐 Web UI published through an HTTP tunnel ⚡ Docker first, Localtonet Linux service and Docker client covered
Illustration of a local OpenAList server on port 5244 reached by a laptop and phone through an HTTP tunnel
A tunnel lets remote devices reach an OpenAList instance that runs on a private network.

Why run OpenAList, and why add a tunnel?

Many people end up with files scattered across a local disk, a NAS and a few cloud drives. A file listing application gives all of that a single web front end, with browsing, previews and permissions in one place. The OpenAList documentation site describes the following capabilities:

  • Multiple storage providers, including local storage, Aliyundrive, OneDrive and Google Drive, with the list described as easy to extend.
  • WebDAV support for accessing files with standard WebDAV clients.
  • Protected routes: password protection and authentication for specific paths.
  • File preview for video, audio, office documents, PDF, code and images.
  • Package and batch download, using the browser's stream API for package downloads without server usage, and Aria2 for folder batch downloads.
  • Single sign-on, including automatic registration of an OpenAList account on first SSO login.
  • Offline download of torrent content to a chosen directory, which the docs say needs a good network environment.
  • Crypt, which lets you store encrypted data on a remote provider so the provider only sees the encrypted container, not your data.
  • Extras such as a text editor, README and HTML rendering, file permalinks, a Cloudflare Workers proxy, and light and dark modes.

The latest release we reviewed is v3.45.31. Its notes describe one change: a security-related rebuild with Go 1.27.3 to distrust compromised eMudhra intermediate certificates. The release lists 22 assets. Before you modify or redistribute the code, read the LICENSE file in the repository, since the license terms govern what you may do. We are not lawyers, and this is a pointer rather than legal advice.

Running OpenAList at home or on a small server solves the "one place for my files" problem, but it creates a second one: the web UI listens on a private address. To use it from a phone on mobile data or from an office, or to share a link with someone, you would normally open an inbound port on your router, set up a VPN, or use a tunnel. With Localtonet, the client on your machine makes an outbound connection to one of our relay servers, and the HTTP tunnel gives you a public HTTPS address that forwards to your local service. There is no inbound port forwarding, no firewall change and no public IP required. The tunnel is available only while the client device is connected and the tunnel is running.

We keep those two jobs separate on purpose. First we get OpenAList installed and verified locally, because a tunnel in front of a broken service only gives you a broken public URL. Then we publish it.

OpenAList vs OpenList, and what we could verify

The naming in this ecosystem is confusing, and it decides which commands you can safely copy. Alist is an older open-source file listing project, and community forks followed. The one in this guide is OpenAList, maintained by AlliotTech and described as a fork of Alist based on v3.45.0, aiming to be more secure, customizable and user-friendly. A different project called OpenList, maintained by the OpenListTeam, has its own documentation at doc.oplist.org and its own conventions. According to those OpenList docs, it uses the Docker image openlistteam/openlist, the in-container data path /opt/openlist/data, the admin password variable OPENLIST_ADMIN_PASSWORD, and image tag suffixes such as -aio, -ffmpeg, -aria2 and -lite. After v4.1.0 its image also dropped PUID and PGID in favor of a built-in openlist user (UID 1001).

Search results for this family of tools are full of OpenList instructions. None of the OpenList items above are documented as applying to OpenAList, so we do not use them here. That includes OpenList's admin reset command, its log message wording, and the long list of storage drivers (such as FTP, SFTP and S3) and visitor web upload that a third-party blog attributes to OpenList. The OpenAList documentation we reviewed confirms WebDAV, protected routes, previews, Crypt, offline download and SSO, and says nothing about those other items.

What we could and could not re-confirm

When we re-checked this article against current evidence, the OpenAList README text available to us was truncated, so several specifics could not be re-confirmed from it. Rather than repeat the caveat in every paragraph, here it is once, together with how this guide handles each item.

Detail Status How this guide handles it
Image name alliot/alist:latest Not re-confirmed from the current README text Used in examples; confirm it on the repository README before pulling, then inspect the image
Web UI on port 5244, data path /opt/alist/data Not re-confirmed from the current README text Used in examples; docker image inspect shows the declared ports and volumes so you can confirm both
ALIST_ADMIN_PASSWORD variable and ./alist server command Not re-confirmed from the current README text Treated as optional, with a fallback that does not depend on them
Go version for source builds, exact build commands, binary asset names Not available in the evidence Described generically; the repository build instructions are authoritative
Admin username, reset command, log wording Not available in the evidence for OpenAList We do not quote any; the logs of your own container are the source of truth
WebDAV path and port WebDAV support confirmed, endpoint details not Confirm the path in the application's settings or the docs site
Check the image name before you run anything

Open the OpenAList README on GitHub (AlliotTech/openalist) and confirm the Docker image name and data path before you run the examples below. Do not substitute openlistteam/openlist, /opt/openlist/data or OPENLIST_ADMIN_PASSWORD from the OpenList documentation, because those belong to a different project.

Prerequisites

For the Docker path you need very little:

  • A Linux, macOS or Windows machine that can run Docker, with Docker Engine or Docker Desktop installed and the daemon running. Check with docker version.
  • Permission to run Docker commands, either as root, through sudo, or as a member of the docker group.
  • TCP port 5244 free on the host. This is the port the examples publish, and we show below how to confirm it from the image itself. If it is taken, change only the host side of the mapping.
  • A directory on the host for persistent data. Without a mounted volume, your configuration and database disappear when the container is removed.
  • For remote access, a free Localtonet account and the Localtonet client on a machine that can reach the OpenAList port.

Binary installs need a release archive from GitHub Releases that matches your operating system and CPU architecture. Source builds additionally need Git, a Go toolchain recent enough for the repository, and a C compiler, because the SQLite driver used in this family of projects relies on CGO. We cover those paths in a later section.

Choosing the install method

Method Best for Notes
Docker (docker run or Compose) Most home servers and VPS hosts; easy updates and clean removal Restart handling is one flag; the image can be inspected before you run it
Prebuilt binary Hosts without Docker, or when you want a plain process Pick the asset for your OS and architecture on the release page; run it under a supervisor such as systemd
Build from source Contributors and people who want to audit or patch the code Needs Git, Go and a C compiler; follow the repository's own build instructions

Install OpenAList with Docker

Terminal window showing a Docker run command that maps port 5244 and mounts a data volume
Run the container with port 5244 published and a persistent data volume.

Start by pulling the image and asking Docker what it declares. This is standard Docker behavior, and it replaces guesswork about ports and paths with facts from the image you are about to run:

docker pull alliot/alist:latest
docker image inspect alliot/alist:latest --format 'ports={{json .Config.ExposedPorts}} volumes={{json .Config.Volumes}}'
docker image inspect alliot/alist:latest --format 'workdir={{.Config.WorkingDir}} cmd={{json .Config.Cmd}} entrypoint={{json .Config.Entrypoint}}'

If the exposed port is 5244 and the data directory is /opt/alist/data, the examples below work as written. If your output differs, use the values it reports. Not every image declares a volume, so an empty volumes field does not mean there is no data directory. In that case, check the README or open a shell in a running container to see where files are written.

Next, create a host directory for the data. We use /opt/openalist/data as an example. The host path is your choice, so pick a location with enough space and sensible permissions.

sudo mkdir -p /opt/openalist/data

Then start the container. The flags -d, --restart=unless-stopped and --name are standard Docker options that we added for convenience:

docker run -d \
  --name openalist \
  --restart=unless-stopped \
  -p 5244:5244 \
  -v /opt/openalist/data:/opt/alist/data \
  alliot/alist:latest

Docker creates the container and starts it in the background. If you want the service reachable only from the host itself until the tunnel is running, bind the published port to the loopback interface by changing the mapping to -p 127.0.0.1:5244:5244. That is a general Docker feature, not an OpenAList setting. With that mapping, a Localtonet client running directly on the same host can still reach the web UI, but other machines on your LAN cannot, and neither can a containerized client (more on that in the Localtonet section).

The same setup with Docker Compose

Here is a Compose file that expresses the same settings as the command above. It is our own translation of the docker run flags, not a copy of a maintainer sample:

services:
  openalist:
    image: alliot/alist:latest
    container_name: openalist
    ports:
      - "5244:5244"
    volumes:
      - ./data:/opt/alist/data
    restart: unless-stopped

Save it as docker-compose.yml in a directory such as /opt/openalist, and run these commands from that directory:

docker compose pull
docker compose up -d

Compose creates a data directory beside the file the first time it runs, and your OpenAList database and configuration live there. Keep that directory in your backups.

About the latest tag

latest follows new releases, which is convenient but means a pull can change the version you run. If you prefer to control upgrades, pin an explicit version tag. We have not verified the tag naming scheme of the image, so check the tag list on the registry page before pinning one. The latest GitHub release we reviewed is v3.45.31.

Binary and source installs

If you cannot or do not want to use Docker, there are two other routes. The evidence available to us does not include the full command sequences for either, so we give you the parts that are general and label the parts you must check against the repository.

Prebuilt binary

Releases are published on the project's GitHub Releases page, and v3.45.31 lists 22 assets. Choose the one that matches your operating system and CPU architecture (uname -m on Linux prints it). We cannot list the exact asset names, so read them on the release page. After extracting the archive into a dedicated directory, make the file executable if needed and start it. Earlier README text used the form below, which we could not re-confirm, so if it fails, check the README for the current start command:

mkdir -p /opt/openalist
cd /opt/openalist
chmod +x ./alist
./alist server

Run it in the foreground first and read the output, so that you see any port conflict or permission error immediately. Press Ctrl+C to stop it. For anything beyond a quick test, run it under a process supervisor so that it restarts after reboots.

A systemd unit for the binary

This is a generic unit file, not a maintainer-provided one. It assumes the binary is /opt/openalist/alist and that the server subcommand starts the web service. Adjust both if your release differs.

sudo useradd --system --home /opt/openalist --shell /usr/sbin/nologin openalist
sudo chown -R openalist: /opt/openalist
sudo tee /etc/systemd/system/openalist.service > /dev/null <<'EOF'
[Unit]
Description=OpenAList
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=openalist
WorkingDirectory=/opt/openalist
ExecStart=/opt/openalist/alist server
Restart=on-failure

[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable --now openalist
sudo journalctl -u openalist -e

The WorkingDirectory matters because the application writes its data relative to where it runs. Back up that directory the same way you would back up the Docker data directory.

Build from source

A source build needs Git, a C compiler and a Go toolchain. The repository's go.mod file states the minimum Go version, so read its go directive instead of relying on a number from an article. The maintainers built v3.45.31 with Go 1.27.3, so a toolchain at least that recent is a sensible choice if you want your own build to match the certificate-trust fix in that release. Because the SQLite driver used in this family of projects relies on CGO, a missing C compiler produces a build that cannot use SQLite. The generic first steps are:

git clone https://github.com/AlliotTech/openalist.git
cd openalist
go version
grep -m1 '^go ' go.mod

The exact build commands and the handling of frontend assets are not in the evidence we could extract, so follow the build section of the repository README rather than a command from us. Source builds are mainly worthwhile if you want to audit the code, test a patch, or run on an architecture that has no prebuilt asset.

Find or set the admin password

Terminal showing container logs with the admin password line highlighted and its value masked
An example of a masked credential line in container logs; check your own logs for the exact wording.

Applications in the Alist family typically create an administrator account on first start, and the first-run output is the first place to look for its credentials. We could not confirm the exact OpenAList log wording or the default username from current evidence, so we search by keyword instead of quoting a message.

Look in the container logs

docker logs openalist
docker logs openalist 2>&1 | grep -i -E 'password|admin'

If a line reports the creation of an admin account, it should name the account and show an initial password. Use exactly what it shows. If the logs contain nothing relevant, the service may use a different first-run flow, so check the OpenAList documentation site (alist.iots.vip) and the README for your version.

Try setting the password up front

Earlier README text described an ALIST_ADMIN_PASSWORD environment variable for choosing the initial password. We could not re-confirm it from the current README extraction, so treat it as something to test rather than rely on. If you want to try it, add it when you create the container, using a strong value of your own:

docker run -d \
  --name openalist \
  --restart=unless-stopped \
  -p 5244:5244 \
  -v /opt/openalist/data:/opt/alist/data \
  -e ALIST_ADMIN_PASSWORD='choose-a-long-unique-password' \
  alliot/alist:latest

Then try to sign in with that password. If it works, the variable is honored. If it does not, remove the container and its data directory (only on a brand-new install) and fall back to the log-based credential. In Compose, the same value goes under an environment: key. A password in a Compose file or shell history sits in plain text on disk, and anyone who can run docker inspect on the host can read an environment variable, so keep the file private and change the password after your first sign-in.

Resetting a lost password

We have no verified OpenAList reset command. The openlist admin commands that appear in other guides belong to OpenList and are not documented for this project. If you lose access, look for an admin command in the OpenAList README or docs for your version. On a fresh install with nothing you care about, removing the data directory and starting again recreates the initial account, but that wipes all configuration, so do it only on a brand-new setup.

Whichever route you use, sign in once, then change the password in the admin interface to something only you know. A generated password has been printed into a log file, and logs tend to get copied around.

Verify the installation locally

Before you involve any tunnel, confirm the service from the host itself. Work through these checks in order, because each one narrows down where a problem lives.

1

Confirm the container is running

Run docker ps. You should see a container named openalist with a status beginning "Up" and a PORTS column showing the host port mapped to 5244. If the container is missing, run docker ps -a and then docker logs openalist to see why it exited.

2

Test the port from the command line

Run curl -I http://localhost:5244. Any HTTP response line, such as a 200 or a redirect, means the web server is answering. A "connection refused" result means nothing is listening on that port yet. If the container logs show a different listening port than 5244, use that one for every later step.

3

Open the web UI in a browser

Visit http://localhost:5244 on the host, or the host's LAN IP address with the same port from another device on your network (if your port mapping is not limited to the loopback interface).

4

Sign in as the administrator

Use the credential from the logs, or the password you tested through the environment variable. After you are in, change the password and review the admin settings before you add any storage.

5

Add one storage and browse it

Add a single local storage entry that points to a directory visible inside the container, then browse it in the UI. To list a host directory you must mount it into the container with an additional -v option, because the container cannot see arbitrary host paths. The fields of the storage form depend on the driver and version, so follow the labels in the UI.

Only continue once step 5 works. A local storage entry that lists and previews a test file proves that the container, the volume mapping and the web application are healthy together.

Daily operations: logs, restarts, updates, backups

A file listing service quietly runs for months. These routine commands keep it that way. They use standard Docker behavior, not OpenAList-specific features.

Logs, stop and start

docker logs -f openalist
docker stop openalist
docker start openalist
docker restart openalist

With --restart=unless-stopped (or the equivalent Compose setting), Docker starts the container again after a host reboot unless you stopped it manually.

Updating

Because your data lives in the mounted directory, replacing the container does not remove your configuration. For a docker run deployment, pull the new image, remove the old container and start a new one with the same flags:

docker pull alliot/alist:latest
docker stop openalist
docker rm openalist
# then repeat your original docker run command

For Compose, run docker compose pull followed by docker compose up -d in the project directory. For a binary install, replace the executable and restart the service. Back up the data directory before upgrades and read the release notes. The v3.45.31 notes only mention the security rebuild, but future releases may differ.

Backups

Copy the whole host data directory (for example /opt/openalist/data) to another disk or machine. For the most consistent copy, stop the container first, because the application uses a database file. Test a restore at least once by starting a second container against a copy of the backup on a different host port.

Time zone and file permissions

The OpenList image reads TZ and UMASK variables, but we have not confirmed that the OpenAList image does, so we leave them out of the commands above. If you see permission errors on a mounted directory, the usual cause is that the user inside the container cannot write to the host directory. Docker has a general --user UID:GID option for running a container as a particular user. We have not verified how this image behaves under it, so test it on a non-critical directory first.

Reach OpenAList remotely with a Localtonet HTTP tunnel

Diagram of a remote browser reaching OpenAList on localhost:5244 through a Localtonet HTTP tunnel
Requests travel from the public URL through the HTTP tunnel to port 5244 on the local machine.

Everything up to this point is the OpenAList installation. The tunnel is a separate layer that we add on top, and the OpenAList project does not cover it. This section explains the Localtonet side in full: installing the client, handling the auth token, creating and starting the tunnel, and the Docker networking trap that catches many people. For the authoritative field list in the current dashboard, see the Localtonet HTTP tunnel documentation, since labels and options can change over time.

🔌 Outbound connection only The Localtonet client on your device connects out to a relay server. You do not open inbound ports on your router or change firewall rules.
🌐 Public HTTPS address HTTP tunnels serve your local web application at a public HTTPS address, using a random subdomain, a custom subdomain or a custom domain, depending on the Process Type you choose.
▶️ Explicit lifecycle Creating a tunnel does not start it. You press Start, and you can stop or delete it later. The public address works only while the client is connected and the tunnel is running.
🎯 Local target An HTTP tunnel points to a local IP address and port on, or reachable from, the client device. For this guide that is the OpenAList port on the Docker host.

Install the Localtonet client on Linux

The Localtonet downloads page offers builds for Windows, macOS, Linux (including ARM, ARM64 and MUSL variants), Android and Docker, plus Termux and experimental OpenWrt packages. On a Linux server the most convenient option is the installable package, because it registers a systemd service. The DEB and RPM packages exist for x64 and ARM64, and they require systemd 247 or newer and OpenSSL 3, which covers distributions such as Debian 12, Ubuntu 22.04 and later, and RHEL 9. Download the package that matches your distribution and architecture from the Localtonet documentation page, then follow these three steps.

1

Install the downloaded package

Open a terminal in the directory that contains the package. On Debian or Ubuntu x64 run sudo apt install ./localtonet-linux-x64.deb (use localtonet-linux-arm64.deb on ARM64). On Fedora or RHEL x64 run sudo dnf install ./localtonet-linux-x64.rpm (use localtonet-linux-arm64.rpm on ARM64).

2

Set your AuthToken and check the configuration

Edit /etc/localtonet/auth-token as root and replace DUMMY_AUTH_TOKEN with your token on a single line. Then protect the file with sudo chmod 600 /etc/localtonet/auth-token and validate it with sudo localtonet --headless --authtoken-file /etc/localtonet/auth-token --check-config.

3

Start the service

Once the configuration check succeeds, run sudo systemctl enable --now localtonet.service. To watch the client output, run sudo journalctl -u localtonet.service.

The same commands in one block, for a Debian or Ubuntu x64 host:

sudo apt install ./localtonet-linux-x64.deb
sudo nano /etc/localtonet/auth-token
sudo chmod 600 /etc/localtonet/auth-token
sudo localtonet --headless --authtoken-file /etc/localtonet/auth-token --check-config
sudo systemctl enable --now localtonet.service
sudo journalctl -u localtonet.service

To upgrade later, install the new package and run sudo systemctl restart localtonet. Your configuration is preserved. The documentation also describes a separate localtonet-vpn.service for VPN use. You do not need it for an HTTP tunnel, and you should keep the regular localtonet.service for this guide.

Treat the auth token like a password

The token identifies the device that runs your tunnels. Keep it in the root-owned, mode 600 file shown above, never paste it into a public issue, screenshot, repository or shared Compose file, and do not place a real token in any example you publish. The token field in the packaged file starts as the placeholder DUMMY_AUTH_TOKEN, so a failing --check-config usually means the placeholder is still there.

Using the Localtonet Docker client instead

Docker is also listed as a download option for the client, which suits hosts where you prefer to keep everything in containers. Take the exact image reference and run command from the Docker entry on the Localtonet documentation page rather than from this article, because we do not want to quote an image name or flag that may have changed. The part you must get right yourself is networking.

127.0.0.1 inside a container is not the host

Inside a Localtonet container, 127.0.0.1 and localhost refer to that container, not to your Docker host and not to the OpenAList container. A tunnel target of 127.0.0.1:5244 therefore fails, usually as a connection error on the public address, even though the same target works from a client installed directly on the host.

Use one of these approaches, all of which rely on general Docker behavior:

  • Target the host's LAN IP and the published port. If OpenAList was started with -p 5244:5244, a containerized client can reach HOST_LAN_IP:5244. This does not work if you bound the published port to 127.0.0.1 only, so for this approach publish the port normally and rely on the host firewall.
  • Use host networking for the Localtonet container on Linux. With --network host, the container shares the host's network stack, so 127.0.0.1:5244 reaches a published OpenAList port on the host. This option behaves differently on Docker Desktop for macOS and Windows.
  • Target the OpenAList container's address on a shared Docker network. Put both containers on the same user-defined network and use the OpenAList container's IP address on that network as the target. Since the Localtonet target is an IP address and port, look the address up with docker inspect and remember that it can change when the container is recreated, which is why the first approach is usually simpler.

Create and start the HTTP tunnel

With the client running and authenticated, create the tunnel in the dashboard. The sequence follows our general workflow for HTTP tunnels. We name only the options our documentation establishes, because the exact screen layout can vary by client version.

1

Confirm the device is connected

Create a free account on the registration page if you do not have one, and check that the dashboard shows the token or device you configured as connected.

2

Choose the HTTP tunnel type and Process Type

Select the HTTP tunnel, then pick Random Sub Domain, Custom Sub Domain or Custom Domain. Select your AuthToken and a relay server from the values the dashboard offers, rather than relying on a fixed list. For a custom domain, check the current Localtonet documentation for the DNS requirements before you change any DNS records.

3

Set the local target to OpenAList

Enter the IP address and port that the client can reach, for example 127.0.0.1 and 5244 for a client installed on the same host as the OpenAList container. For a containerized client, use the addresses described in the Docker networking section above.

4

Start the tunnel

Press Start. A newly created tunnel is not running until you do. Once it runs, the dashboard shows the public address assigned to it.

5

Open the public HTTPS address and sign in

Visit the address from a device outside your network, for example a phone on mobile data. You should see the same OpenAList login page you saw locally. When you no longer need remote access, stop or delete the tunnel.

Where the 127.0.0.1 target works

The local target must be reachable from the machine or container running the Localtonet client. If the client runs on the Docker host and you published the OpenAList port, then 127.0.0.1 and that port work. If the client runs on a different machine, use the Docker host's LAN IP address and make sure the published port is not restricted to the loopback interface.

What the HTTP tunnel covers

An HTTP tunnel forwards web traffic, so it covers the browser-based interface. The OpenAList documentation lists WebDAV support. WebDAV is built on HTTP as a general networking fact, so it may be reachable through the same web endpoint, but we have not confirmed the exact WebDAV path or settings in OpenAList. Check the in-app settings or the documentation site for the version you run before you point a WebDAV client at the public address. Any non-HTTP service would need a different tunnel type and a port you have confirmed from your own configuration, not from this article.

Access method Evidence status What to do
Web UI Port 5244 used in this guide; confirm with image inspection and logs Point a Localtonet HTTP tunnel at that port
WebDAV Support documented; endpoint path and port not established in our evidence Confirm the path in the application or its docs before relying on it through a tunnel
Other protocols Not confirmed for OpenAList Do not assume ports or protocols; verify in your own settings first

Post-tunnel verification checklist

A tunnel can fail at several layers: the OpenAList service, the Localtonet client, the target address or the tunnel itself. After you press Start, go through this checklist in order. The first failing row tells you which layer to fix.

Check How Expected result
Service answers locally On the client's machine run curl -I http://127.0.0.1:5244 An HTTP status line. If this fails, fix OpenAList before touching the tunnel.
Client service is healthy On a packaged Linux install run sudo systemctl status localtonet.service and sudo journalctl -u localtonet.service Active service with no authentication errors in the log
Device shows as connected Look at the token or device state in the Localtonet dashboard Connected
Tunnel is started Check the tunnel entry in the dashboard Running, not merely created
Target is correct Compare the tunnel's IP and port with the real address; from a containerized client, test reachability from inside the container The target is reachable from where the client runs (not 127.0.0.1 inside a container)
Public address loads Open the assigned HTTPS address from a phone on mobile data The OpenAList login page appears
Authentication is enforced Open the address in a private browser window without signing in Only what you intended to be public is visible; protected paths ask for a password
Sign-in and one real action work Sign in, browse a storage, open a preview and download a small file Pages, previews and downloads complete over the public address
Stopping closes access Stop the tunnel and reload the public address The address stops serving OpenAList

Secure the public exposure

Before and after comparison of an unprotected public OpenAList URL and one with several protections added
Public exposure calls for a strong password, restricted access and current software.

A tunnel makes your service reachable from the internet. It does not change who is allowed to use it, and it does not bypass your application's authentication. The safety of the public address depends mostly on how well OpenAList itself is configured. Treat this checklist as mandatory before you share the URL.

  • Change the admin password immediately and use a long unique value. The initial credential was printed to logs or set in an environment variable, so assume it has leaked into more places than you want.
  • Review guest and anonymous access. Check the admin settings for whether visitors can browse without signing in and what actions they have. We have not confirmed which guest options your version offers, so look at the actual settings instead of assuming defaults.
  • Use protected routes. The project documents password protection and authentication for specific paths. Apply it to any directory that should not be public.
  • Consider Crypt for cloud-stored data. The documented Crypt feature stores encrypted data on a remote provider so the provider only sees the encrypted container.
  • Use SSO deliberately. If you enable single sign-on, remember that it can automatically register OpenAList accounts, so check who is allowed to sign in at the identity provider.
  • Use least privilege for storage. Mount into the container only the host directories you want listed, and avoid mounting your home directory or the filesystem root. Use read-only mounts for content that OpenAList only needs to display.
  • Mind the cloud credentials. If you connect cloud storage accounts, the application holds access to them, so a compromised admin account becomes a path into those accounts.
  • Keep the software current. The latest release we reviewed was a security-driven rebuild. Watch the repository's releases and update regularly.
  • Stop the tunnel when you do not need it. A stopped tunnel is a closed door. Delete tunnels you no longer use.
  • Keep the token private. Anyone with your Localtonet auth token could run tunnels as your device.
A public login page invites guessing

Once the web UI has a public address, expect automated login attempts over time. Strong passwords are the first defense. We cannot confirm from the evidence whether OpenAList has built-in login rate limiting or two-factor authentication, so verify what your version offers in its settings and do not assume it is there.

Does a random subdomain protect the service?

A random subdomain is hard to guess, but an unguessable address is not an access control. Addresses show up in browser history, chat messages and logs. Rely on the application's authentication and treat the address as public once you have shared it. If you only need access for yourself, our VPN Manager (covered below) is a better fit than a public address.

Troubleshooting

The container exits right after starting

Run docker logs openalist. Typical causes are a port conflict (something else already uses 5244, in which case Docker reports the error when starting), a data directory the process cannot write to, or a typo in the image name. If port 5244 is taken, change only the host side of the mapping, for example -p 8080:5244, then use 8080 locally and as the tunnel target.

I cannot find the admin password

Run docker logs openalist and search for "password" or "admin". If you removed and recreated the container with the same data volume, the account already exists and a new credential may not be printed. If your logs have rotated, you may not be able to retrieve it. See the note on resets in the password section.

The page loads on localhost but not from another device on my LAN

Check whether you bound the port to 127.0.0.1 only. That mapping blocks other machines by design. Also check the host firewall for the published port.

My data disappeared after I recreated the container

This happens when the volume was not mounted, or when you mounted a different host path the second time. Inspect the mounts with docker inspect openalist and confirm that a host directory maps to the container's data directory. Always use the same host path in every run.

Permission denied on a mounted directory

The user inside the container cannot read or write the host directory. Check ownership and mode on the host. Running the container with --user UID:GID matching the directory owner is a general Docker option, but test it on a non-critical path first because we have not confirmed this image's behavior with it.

The tunnel is created but the public address shows an error

  • Confirm the tunnel was started, not only created.
  • Confirm the Localtonet client is still connected. On a packaged Linux install, check sudo systemctl status localtonet.service and the journal output.
  • Confirm the local target matches the real address and port. Test curl -I http://127.0.0.1:5244 on the same machine as the client.
  • If the client runs in a Docker container, remember that 127.0.0.1 is the container itself. Switch to the host's LAN IP and published port, or to host networking on Linux.
  • If the client runs on a different machine from OpenAList, make sure that machine can reach the OpenAList host's IP and port.

The Localtonet service will not start

Run the check command again: sudo localtonet --headless --authtoken-file /etc/localtonet/auth-token --check-config. A failure usually means the token file still holds the DUMMY_AUTH_TOKEN placeholder, has more than one line, or is not readable by the service. Also confirm that your distribution meets the documented minimums of systemd 247 and OpenSSL 3.

The UI loads remotely, but links or assets point to the wrong address

Applications that build absolute links sometimes need to know their public address. We have not confirmed which setting, if any, OpenAList uses for that, so look through the site-related options in the admin settings if links point to localhost. Report the behavior to the project if you believe it is a bug.

Large file uploads or downloads fail through the tunnel

Test the same transfer directly on the LAN first. If it works locally and fails remotely, the limit may sit in a browser timeout, your upload bandwidth or an intermediate layer. We do not publish bandwidth or size limits for tunnels here, because such details can vary by plan, so check the current Localtonet documentation and your plan before you plan large transfers.

When another Localtonet feature is a better fit

OpenAList is a full application with storage drivers, previews and user management. If your only goal is to publish a folder of files, a simpler option exists in our own product. Localtonet File Server publishes a local folder path directly, with three sub-types: Default (a browser-based file manager), SFTP (for SFTP clients, automation and CI/CD) and WebDAV (to mount the folder as a network drive). You can read more in our File Server tunnel guide.

Goal Good fit Why
One front end over local storage plus several cloud drives OpenAList behind an HTTP tunnel It aggregates multiple storage providers and adds previews and per-path protection
Share a single folder quickly with a built-in file manager Localtonet File Server (Default) No separate application to install; you point it at a folder path and press Start
Mount a folder as a network drive on Windows or macOS Localtonet File Server (WebDAV) The WebDAV sub-type is designed for native OS network drive mounting
Private access for yourself only Localtonet VPN Manager It is our actual private mesh VPN feature; standard tunnels are not a VPN

These are not mutually exclusive. Many people run an application like OpenAList for browsing and previews, and use other tools for different jobs.

Frequently asked questions

What port does OpenAList use, and what is the local URL?

This guide uses port 5244, so the local URL is http://localhost:5244. We could not re-confirm it from the current README text, so check with docker image inspect for the declared port and docker ps or the container logs for the actual listening port. Whatever port you confirm is the target for a Localtonet HTTP tunnel.

Where do I find the OpenAList admin password in Docker?

Start with docker logs openalist and search for "password" or "admin", because first-run output is where this family of applications reports a generated credential. We cannot quote the exact wording for OpenAList. You can also test the ALIST_ADMIN_PASSWORD variable, which earlier README text described but which we could not re-confirm. Change the password after your first sign-in either way.

Is OpenAList the same as OpenList or Alist?

No. OpenAList is a community-driven fork of Alist based on v3.45.0, maintained by AlliotTech. OpenList is a separate project with its own image (openlistteam/openlist), data path, environment variables and admin commands. Use instructions written for OpenAList, and be careful when copying commands from OpenList documentation.

Do I need to open a router port to reach OpenAList remotely?

Not with Localtonet. The client on your device makes an outbound connection to a relay server, and the HTTP tunnel gives you a public HTTPS address that forwards to the OpenAList port. No inbound port forwarding, firewall change or public IP is required. The tunnel works only while the client is connected and the tunnel is started.

Why does my tunnel to 127.0.0.1:5244 fail when the Localtonet client runs in Docker?

Inside a container, 127.0.0.1 refers to the container itself, not to your Docker host. Point the tunnel at the host's LAN IP and the published port, use host networking on Linux, or target the OpenAList container's address on a shared Docker network. A client installed directly on the host can use 127.0.0.1 as normal.

Is exposing OpenAList through a tunnel safe?

It can be, if you treat it like any internet-facing application. A tunnel does not replace authentication or authorization. Set a strong admin password, review guest permissions, protect sensitive paths, mount only the directories you need, keep the software updated and stop the tunnel when you do not need it.

Can I install OpenAList without Docker?

Yes. Prebuilt binaries are published on GitHub Releases, and you can also build from source with Git, Go and a C compiler. Check the repository README for the current start and build commands, then run the binary under a supervisor such as systemd. You create the Localtonet HTTP tunnel against the same port in the same way.

Start with Localtonet

Get OpenAList running and verified locally, then create an HTTP tunnel with Localtonet to reach its web UI over HTTPS from anywhere. Start the tunnel when you need access and stop it when you are done.

Get Started Free →

Corrections & updates

Substantive changes approved by the Localtonet editorial team are listed transparently below.

Reviewed and updated for accuracy and completeness.

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.

Support