Build a private website-change monitor locally, verify it on port 5000, and publish the interface only when remote access is required
changedetection.io is an open-source application for watching web pages, comparing revisions, and sending notifications when relevant content changes. In this guide, we install it as a Python package inside an isolated virtual environment, assign persistent local storage, start the web interface, and verify the complete monitoring workflow. After the local installation works, we connect it to a Localtonet HTTP tunnel so an authorized user can reach the interface remotely without configuring inbound router port forwarding, changing firewall rules, setting up a VPN, or requiring a public IP address.
📋 What's in this guide
How this self-hosted changedetection.io setup works
changedetection.io periodically retrieves watched resources, stores enough state to compare one retrieval with another, and presents the results through a browser-based interface. It can be used for ordinary page updates, price and restock monitoring, changes in documents, JSON API responses, regulatory notices, job listings, software releases, security advisories, and other resources where detecting a meaningful revision is more useful than checking manually.
The application supports filters that narrow the content being monitored. Available project features include trigger text, ignored text, extracted text, regular expressions, CSS selectors, XPath, JSONPath, and jq-based handling for JSON. The project also supports both fast non-JavaScript fetching and browser-based fetching. Features such as interactive browser steps and visual selection require an appropriately configured Playwright or WebDriver fetcher, so installing the basic Python package does not by itself guarantee that every browser automation capability is ready.
In this tutorial, the application and its data stay on the host you control. Python runs the application, a dedicated data directory preserves its state, and the browser interface uses port 5000. We verify that local service before introducing any public endpoint. This order is important because a tunnel cannot repair a failed application, a missing Python dependency, or an incorrect local port.
Why use the pip installation path?
The project documents several self-hosting approaches. Cloning the repository and using Docker Compose is useful when the complete repository deployment is preferred. A standalone container provides process isolation and a straightforward persistent-volume model. Installing the Python package with pip avoids requiring a container runtime and is convenient on a host where Python environments are already understood and managed.
| Installation path | Best suited to | Important characteristic |
|---|---|---|
| Python package with pip | Python-oriented hosts and lightweight manual deployments | Runs directly in a Python environment and can use a dedicated persistent data directory. |
| Standalone Docker image | Hosts already using containers | The documented example publishes port 5000 and maps persistent storage outside the container. |
| Repository with Docker Compose | Repository-based deployments and broader service composition | Uses the project's Compose configuration rather than a direct pip-managed Python environment. |
This article focuses on pip. Do not mix the commands from different installation models. For example, a Python virtual environment has no effect on a copy running inside Docker, while a Docker volume does not preserve data created by a separate host-level Python process.
Prerequisites and planning
Prepare the host before installing the application. You need a working Python installation with pip and virtual-environment support, permission to create directories and install packages inside your own virtual environment, and enough local storage for the watches and history you intend to retain. The host also needs outbound network access to retrieve Python packages and to fetch the websites you monitor.
The supplied project evidence does not establish a single Python version requirement that is safe to hardcode for every changedetection.io release. Check the package metadata for the release you intend to install and use a Python version within that declared range. Do not assume that an old operating-system Python remains compatible with the latest application release.
This guide uses two conceptual locations:
- Virtual environment: an isolated Python environment containing changedetection.io and its dependencies.
- Data directory: a separate writable directory where changedetection.io can retain application state.
Keep those locations separate. Replacing a virtual environment should not require deleting application data. Likewise, backing up application state should not require copying all installed Python packages.
Check Python and pip
On systems where the Python 3 executable is named python3, inspect it with:
python3 --version
python3 -m pip --version
On systems where the Python launcher is named python, use:
python --version
python -m pip --version
Calling pip through python -m pip makes it easier to see which Python interpreter owns the installation. If either command fails, install Python, pip, and virtual-environment support using the supported package-management procedure for your operating system. Package names differ among operating systems and releases, so this guide does not guess an OS-specific package command.
Choose a data location
Select a writable directory on storage that is included in your backup plan. The documented startup command expects a path for the application data directory. Start with an empty directory for a new installation, and do not point the application at a folder containing unrelated files.
The following Unix-like shell example creates a directory in the current user's home directory:
mkdir -p "$HOME/changedetection-data"A PowerShell equivalent is:
New-Item -ItemType Directory -Force "$HOME\changedetection-data"The data directory may reveal watched URLs, monitoring history, notification configuration, and other operational information. Restrict filesystem access to the account running the service, keep backups protected, and never place the directory under a public web root. Before upgrading or migrating the application, make a backup while the process is stopped so that files are not changing during the copy.
Plan access before publishing anything
During installation, access the interface only from the local host. If another machine on the LAN needs to perform the initial test, first determine what address the application is actually listening on and whether local firewall policy permits that connection. Do not expose port 5000 directly through a router.
Remote access comes later through Localtonet. Our client establishes an outbound connection to a Localtonet relay server, so the workflow does not require an inbound router port-forwarding rule, a public IP address, a firewall change, or VPN setup. The tunnel remains available only while the selected client device is connected and the tunnel is running.
Install changedetection.io with Python pip
Use a virtual environment instead of installing the package into the operating system's global Python environment. Isolation reduces conflicts with system-managed packages and makes it easier to replace the application environment later without disturbing other Python software.
Create a dedicated working directory
Choose a location owned by the service account or current user. Keep the virtual environment here while retaining application state in the separate data directory prepared earlier.
Create a Python virtual environment
Run Python's built-in virtual-environment module to create an isolated environment named .venv. Use the Python executable whose version you checked against the package requirements.
Activate the environment
Activate .venv using the command appropriate for your shell. Confirm afterward that Python and pip resolve inside that environment.
Install the changedetection.io package
Install changedetection.io through the active environment's pip. Read any error in full rather than retrying with administrator privileges, because an error may indicate an unsupported Python version or a missing build dependency.
Confirm that the console command exists
Ask the shell to locate changedetection.io. It should resolve inside .venv, not to an unrelated global installation.
Start the application with persistent storage
Run the documented console command with the data-directory argument and port 5000. Keep this terminal open during initial verification so startup messages and errors remain visible.
Commands for a Unix-like shell
mkdir -p "$HOME/changedetection-app"
cd "$HOME/changedetection-app"
python3 -m venv .venv
source .venv/bin/activate
python -m pip install changedetection.io
command -v changedetection.io
changedetection.io -d "$HOME/changedetection-data" -p 5000
If your compatible Python executable is named pythonpython3, use that executable when creating the environment. After activation, pythonpython -m pip
Commands for PowerShell
New-Item -ItemType Directory -Force "$HOME\changedetection-app"
Set-Location "$HOME\changedetection-app"
python -m venv .venv
.venv\Scripts\Activate.ps1
python -m pip install changedetection.io
Get-Command changedetection.io
changedetection.io -d "$HOME\changedetection-data" -p 5000PowerShell execution policy can prevent an activation script from running. Follow the security policy set by the device administrator rather than disabling safeguards globally. Activation is primarily a shell convenience. If necessary, executables can be called directly from the virtual environment, but the exact path syntax depends on the operating system.
Do not build a background service around the application until it starts reliably in a terminal. Foreground operation exposes dependency failures, permission errors, occupied ports, and data-directory problems immediately. The project evidence supplied for this guide does not define one universal system service configuration, account name, or startup path, so we do not invent a systemd, launchd, or Windows service definition.
What a successful startup establishes
A successful launch establishes that the package is installed, the console entry point is available, the selected data location is usable, and the application can attempt to serve its interface on port 5000. It does not yet prove that the browser can connect, that a watch can retrieve a target, or that notification delivery is configured. Test those layers separately.
The pip workflow documents port 5000, but do not infer a listening address from the port alone. A service can bind only to loopback, to a specific interface, or to all interfaces. Use the startup output and operating-system socket tools to determine the actual listening address if connectivity is unclear.
Verify the local web interface before tunneling
On the same host, open:
http://127.0.0.1:5000
Using 127.0.0.1 avoids relying on hostname resolution during the first test. You should receive the changedetection.io browser interface rather than a connection-refused page, an unrelated service, or an error generated by another local proxy.
You can also make a basic HTTP request from the command line. Headers and response bodies can vary by application version, so the important result is that an HTTP response arrives from the expected service.
curl -I http://127.0.0.1:5000/
If the application does not support the request method used by curl -I in your version, make a normal request instead:
curl http://127.0.0.1:5000/Confirm which process owns port 5000
A browser page alone does not prove that changedetection.io owns the port. If the content looks unexpected, inspect the listening process. On Linux, a common inspection command is:
ss -ltnp | grep ':5000'
On macOS or another system with lsof:
lsof -nP -iTCP:5000 -sTCP:LISTENOn PowerShell:
Get-NetTCPConnection -LocalPort 5000 -State ListenThese are operating-system diagnostics, not changedetection.io commands. Availability and required permissions differ by platform. The process identifier should correspond to the Python environment from which the application was launched.
| Test | Expected result | What it proves |
|---|---|---|
| Package installation | changedetection.io resolves inside .venv |
The command was installed in the intended Python environment. |
| Socket inspection | A Python application listens on port 5000 | The process reached the web-serving stage. |
| Local HTTP request | An HTTP response arrives from 127.0.0.1:5000 |
The local network path and web interface are responsive. |
| Browser inspection | The changedetection.io interface renders correctly | The page and browser assets are usable, not merely the TCP port. |
| Test watch | A reachable target can be fetched and checked again | The application can perform its primary monitoring function. |
Test persistence before relying on the installation
Once the interface opens, create a temporary test watch as described in the next section. Stop the foreground process cleanly, restart it with the same -d path and port, and confirm that the watch remains visible. This verifies that you are using the intended persistent directory rather than temporary storage.
If the watch disappears, first compare the startup command and data path used before and after the restart. Do not continue configuring production watches until persistence works. A tunnel makes an interface reachable, but it cannot protect against an incorrectly selected or disposable data directory.
Create and validate the first website watch
Begin with a public page that the host can retrieve without authentication, browser interaction, geographic restrictions, or JavaScript execution. This isolates the fundamental fetch-and-compare process from advanced browser automation. Use a page you control when possible so that you can make a harmless text edit and observe the resulting difference.
In the changedetection.io interface, enter the target page URL using the watch-entry control presented by your installed version, then save or submit it. The exact labels and screen arrangement can change between releases, so this guide does not claim a fixed button name. After the initial retrieval, allow another check to occur or initiate a recheck using the control available in the interface.
A useful first test has three phases:
- Add a stable page and confirm that the initial retrieval succeeds.
- Change a small, known piece of text on the source page.
- Run or await the next check, then inspect the detected difference.
Reduce noise before increasing check frequency
Modern pages often contain timestamps, rotating banners, session identifiers, recommendations, advertisements, counters, and other content that changes on every request. Monitoring an entire page can therefore produce technically correct but operationally useless alerts.
Use changedetection.io's filtering capabilities to focus on stable content. Depending on the target, this can mean selecting a relevant element with CSS or XPath, removing known dynamic text, extracting a specific value, ignoring matching text, or using a regular expression. JSON endpoints can be narrowed with JSONPath or jq. Test the filter against several retrievals before treating the watch as reliable.
Understand JavaScript and browser automation requirements
A standard HTTP fetch works for pages whose relevant content exists in the returned document. Some sites render essential content only after JavaScript runs. Others require clicks, text entry, login, cookie acceptance, or navigation through a sequence of screens.
changedetection.io supports browser-oriented fetchers through WebDriver and Playwright, and browser steps can perform actions such as filling fields and clicking buttons. The visual selector also depends on a suitable Playwright content fetcher. Those components have their own runtime and configuration requirements. The basic pip installation in this guide should not be presented as proof that a browser worker is installed or enabled.
Use reasonable check intervals and comply with the target site's terms, access controls, and applicable policy. Do not use monitoring to bypass authentication, rate limits, robots controls, or other restrictions. Store any credentials required for authorized watches carefully, and limit access to the changedetection.io administration interface because its configuration may expose sensitive target information.
Configure notifications only after detection works
Notification delivery introduces another independent layer: the monitoring result can be correct even when an external notification provider rejects a message. First verify retrieval and difference detection in the web interface. Then add one supported notification destination, trigger a controlled change, and confirm that the destination receives the expected alert.
The project supports more than 85 notification formats, but each provider has its own credentials, endpoint format, permissions, and rate behavior. Follow the format shown by the installed application and the selected provider. Never paste notification secrets into public screenshots, support messages, shell history, or a tutorial.
Expose the verified interface with a Localtonet HTTP tunnel
Once http://127.0.0.1:5000 works on the changedetection.io host, you can make the interface remotely reachable through Localtonet. Use an HTTP tunnel because the local target is a browser-based HTTP application. The Localtonet client must run on the same device or on another device that can reach the selected local IP address and port.
The client establishes an outbound connection to our relay server. The resulting HTTP tunnel provides a public HTTPS address, while the local target remains the changedetection.io HTTP service. Creating the tunnel record is not enough to publish the application. The selected device must be connected, and the tunnel must be started.
Install and run the Localtonet client
Install the Localtonet application for the operating system on a device that can reach the changedetection.io service. Start the client before configuring the tunnel.
Authenticate or select the client device
Use the device-specific authentication token associated with the client that will run the tunnel. Keep that token private and never copy it into documentation, source code, screenshots, or public messages.
Select an available relay server
Choose a server or region currently offered in the Localtonet dashboard. Available server codes can vary, so obtain the value from the current product interface rather than copying a hardcoded example.
Create an HTTP tunnel to the local service
Configure the HTTP tunnel's local target as the IP address and port reachable from the Localtonet client. When both applications run on the same host and the service responds there, use 127.0.0.1 and port 5000.
Choose the appropriate process type
HTTP tunnels can use Random Sub Domain, Custom Sub Domain, or Custom Domain. Each serves the same local content at a public HTTPS address. Availability can vary, and exact custom-domain DNS requirements must be checked against the current dashboard and documentation.
Start the tunnel
Use the Start button after saving the configuration. Tunnel creation and tunnel startup are separate lifecycle actions, so a saved but stopped tunnel will not provide remote access.
Test the assigned public address
Open the assigned HTTPS address from a different network and verify that the changedetection.io interface loads. Stop or delete the tunnel when remote access is no longer required.
For the current product workflow and interface, consult our Localtonet HTTP tunnel documentation. Do not substitute a TCP tunnel merely because the application uses a port. HTTP is the appropriate application-aware tunnel family for this browser interface.
Select the correct local target
If the Localtonet client and changedetection.io run on the same host, first test 127.0.0.1:5000 from that host. If the client runs on another LAN device, 127.0.0.1 would refer to the client device itself, not the changedetection.io host. In that topology, use a LAN address that the client can reach and verify it locally from the client device before starting the tunnel.
Making a service listen on a LAN interface changes its exposure. Apply host firewall policy and restrict which local devices can connect. A simpler security boundary is to run the Localtonet client on the same host and keep the application reachable through loopback, provided that configuration works with the installed application release.
Treat the changedetection.io interface as an administrative application. Before sharing its public address, review the authentication and access-control options available in the installed release. Do not assume authentication is enabled by default. Use strong unique credentials where supported, disclose the URL only to authorized users, and stop the tunnel when it is not needed. Localtonet supplies connectivity, but application authorization remains an application-level responsibility.
Verify the complete remote path
Test from a browser that is not using the same local network, such as a mobile device with Wi-Fi disabled. Confirm that:
- The assigned Localtonet HTTPS address opens.
- The expected changedetection.io interface appears.
- Static assets and navigation load correctly.
- An authorized user can perform an ordinary read-only check of the dashboard.
- Stopping the Localtonet tunnel makes the public address unavailable.
- Restarting the tunnel restores access while the client and local application remain running.
These checks distinguish local application health from tunnel state. If the public address fails, immediately retest http://127.0.0.1:5000 on the application host. A successful local request narrows the problem to client connectivity, target selection, relay selection, tunnel state, or the network path between the client device and the local target.
Routine operation, backups, updates, and safe shutdown
Starting the application again
Return to the working directory, activate the same virtual environment, and start changedetection.io with the same data path and port:
cd "$HOME/changedetection-app"
source .venv/bin/activate
changedetection.io -d "$HOME/changedetection-data" -p 5000The PowerShell equivalent is:
Set-Location "$HOME\changedetection-app"
.venv\Scripts\Activate.ps1
changedetection.io -d "$HOME\changedetection-data" -p 5000If you later create an operating-system service, use absolute paths and a dedicated least-privilege account. Ensure that the account can read and write only the required application data and can execute the intended virtual environment. Because service-manager syntax and the project's runtime requirements can change, validate any service definition against the current changedetection.io documentation and your operating system rather than copying an unverified generic unit.
Stopping safely
For the foreground process, use the terminal's normal interrupt sequence and wait for the process to exit. Stop the Localtonet tunnel separately if remote access should end. Remember that stopping changedetection.io and stopping the tunnel are different operations:
- Stopping changedetection.io leaves the tunnel without a healthy local target.
- Stopping the tunnel removes remote access while leaving local monitoring running.
- Closing or disconnecting the selected Localtonet client makes the tunnel unavailable.
- Deleting a tunnel removes its configuration, while stopping it preserves the configuration for later use.
Back up the persistent data directory
Stop the application before taking a filesystem-level backup unless the current project documentation explicitly confirms that your chosen backup method is safe while the process is writing. Copy the complete data directory, preserve permissions where appropriate, and protect the backup as sensitive operational data.
Test restoration rather than assuming a copied archive is usable. A practical restore test uses an isolated host or directory, a compatible application release, and no production notification destinations. Confirm that watches, history, and expected configuration are present before treating the backup process as complete.
Update conservatively
changedetection.io is actively released, and releases can include feature work, translation changes, bug fixes, and dependency updates. For example, release 0.60.9 included a correction for decimal-comma prices, a Unix timestamp notification filter, login-page language selection, and updates to multiple dependencies. That illustrates why both functional testing and dependency changes matter during an upgrade.
Use this conservative sequence:
- Record the currently installed package version and working startup command.
- Review the release notes for the target version and any migration requirements.
- Stop the Localtonet tunnel if remote administration is not required during maintenance.
- Stop changedetection.io cleanly.
- Back up the complete application data directory.
- Update the package inside its virtual environment using the version strategy you have approved.
- Start the application locally and repeat the interface, persistence, watch, and notification checks.
- Start the Localtonet tunnel only after local verification succeeds.
Standard pip supports package upgrades, but this article does not prescribe an unpinned upgrade command as a universal production policy. Decide whether your environment follows the latest compatible release or an explicitly reviewed version. Pinning a reviewed version improves repeatability, while adopting a newer release may deliver fixes that require additional validation.
A connected Localtonet device does not prove that changedetection.io is healthy, and a healthy local application does not prove that its tunnel is running. Monitor both layers. Our platform-wide Token and Tunnel webhooks can report Connected or Disconnected status for a selected Token Group, but they report Localtonet connectivity events, not changedetection.io watch failures or website changes.
Troubleshooting common installation and access problems
The changedetection.io command is not found
Confirm that the virtual environment is active and that the installation completed without errors:
python -m pip show changedetection.io
python -m pip --versionThe pip output should identify the virtual environment rather than a system-wide location. If the package exists but the console command does not resolve, inspect the virtual environment's executable directory. Do not solve the problem by repeatedly installing globally with administrator privileges, because that can create several conflicting installations.
pip reports a Python compatibility or build error
Read the first meaningful error rather than only the final failure line. Confirm the Python version, package release requirements, platform support, and availability of any required build tools. The appropriate operating-system packages vary, and no universal package-manager command can be given safely here.
If the error follows an attempt to install the newest release, do not randomly select an old version. Review the package metadata and release history, then choose a version deliberately. Security and compatibility updates in dependencies can make arbitrary downgrades risky.
Port 5000 is already in use
Inspect the process that owns port 5000 before stopping anything. It may be another changedetection.io instance or a completely unrelated application. If you intentionally select another port supported by the application, use the same new port consistently in the startup command, browser test, diagnostics, and Localtonet local target.
Never change only the tunnel destination while leaving the application on the old port. Localtonet forwards to the configured target; it does not automatically discover which local port changedetection.io selected.
The browser reports connection refused
Connection refused usually means no process is listening at the tested address and port, or the process stopped after startup. Check the application terminal for an exception, inspect listening sockets, and retry the local URL. Verify that the data directory exists and is writable by the current account.
If the application listens on an address other than the one being tested, use the address shown by the operating-system socket inspection. Do not expose the service on every network interface solely to hide an address-selection problem.
The interface opens locally but not through Localtonet
Work through the path in order:
- Confirm changedetection.io still responds at the local target.
- Confirm the Localtonet client is connected.
- Confirm the tunnel belongs to the intended device token.
- Confirm the configured local IP and port are reachable from that client device.
- Confirm an available relay server was selected.
- Confirm the tunnel was started after being created.
- Test the assigned public address again from an external network.
If Localtonet runs on a different machine, test the changedetection.io LAN URL from that exact machine. A successful request from the application host does not prove that a separate tunnel host can reach it.
The public page loads, but some actions fail
First reproduce the action locally. If it also fails on 127.0.0.1:5000, investigate changedetection.io rather than the tunnel. Check the foreground output, application behavior, permissions, and target website response.
If the action works locally but not remotely, compare the browser's network errors and verify that the public page is being accessed through the assigned HTTPS address. Avoid hardcoding a local hostname into browser bookmarks or application settings unless the current project documentation specifically requires it.
A watch never detects a visible change
Confirm that the fetched content actually contains the changed value. A browser may display JavaScript-rendered content that a simple HTTP fetch never receives. Inspect the watch history and fetched output, then determine whether a browser-based fetcher is required.
Also review filters. A CSS selector, XPath expression, ignored-text rule, regular expression, JSONPath, or jq filter can exclude the content you expected to monitor. Temporarily simplify the test against a controlled page, then reintroduce filters one at a time.
A watch reports changes on every check
Look for dynamic timestamps, rotating content, request identifiers, advertisements, random ordering, visitor-specific data, or anti-automation pages. Narrow the monitored content to a stable element and ignore known volatile regions. Increasing the interval does not eliminate noisy comparisons if every response is structurally different.
Notifications do not arrive
Verify that the watch itself recorded a qualifying change. Then test the selected notification integration, destination, and credentials. Check whether the provider rejected the request, rate-limited it, placed email in spam, or requires additional permissions. Keep notification troubleshooting separate from tunnel troubleshooting because changedetection.io can send outbound notifications without its administrative interface being publicly exposed.
Data disappears after a restart
Compare the exact -d argument used on every launch. Relative paths can point to different locations when the current working directory changes, which is why this guide uses an explicit path. Confirm that the service account has permission to use the directory and that no cleanup mechanism treats it as temporary storage.
Frequently asked questions
What port does the pip installation of changedetection.io use in this guide?
The documented startup example uses port 5000, and this guide starts the application with -p 5000. Verify it locally at http://127.0.0.1:5000. If you intentionally select another supported port, update every local test and the Localtonet tunnel target to match.
Why should changedetection.io be installed in a virtual environment?
A virtual environment isolates the application and its Python dependencies from the operating system's Python packages and other projects. It also allows the software environment to be replaced independently of the persistent changedetection.io data directory.
Does the pip installation include Playwright or a complete browser worker?
Do not assume that it does. changedetection.io supports Playwright and WebDriver-based capabilities, including JavaScript rendering, visual selection, and browser steps, but those features require an appropriately configured browser fetcher. The basic pip workflow in this guide establishes the core web application and does not claim that every browser automation dependency is installed.
Should I use a Localtonet HTTP tunnel or TCP tunnel?
Use an HTTP tunnel for the changedetection.io browser interface. The local application speaks HTTP, and a Localtonet HTTP tunnel provides a public HTTPS address that serves the local web content. Raw TCP tunnels are intended for services where forwarding the TCP connection itself is the relevant requirement.
Does creating the Localtonet tunnel make it immediately available?
No. Creating a tunnel and running it are separate lifecycle actions. The selected Localtonet client must be connected, and the tunnel must be started with the Start button. It can later be stopped or deleted.
Do I need router port forwarding or a public IP address?
No. The Localtonet client establishes an outbound connection to our relay server, so this workflow does not require inbound router port forwarding, firewall changes, VPN setup, or a public IP address. The tunnel is available only while the selected client is connected and the tunnel is running.
Can the Localtonet client run on a different device?
Yes, provided that the client device can reach the changedetection.io host and port. In that arrangement, do not configure 127.0.0.1 unless changedetection.io also runs on the client device. Use a reachable local address, verify it from the client device, and apply appropriate LAN firewall restrictions.
Does Localtonet secure the changedetection.io login automatically?
Localtonet supplies the remote connectivity path and a public HTTPS address for an HTTP tunnel. Authentication and authorization inside changedetection.io remain application responsibilities. Review the controls available in the installed release, enable appropriate protection, use strong credentials, and stop the tunnel when remote access is not required.
Will changedetection.io keep monitoring if I stop the Localtonet tunnel?
Yes, as long as the changedetection.io process itself remains running and retains the outbound connectivity required to fetch watched resources and deliver configured notifications. Stopping the Localtonet tunnel removes the public administration path but does not stop the local application.
Connect your verified changedetection.io instance with Localtonet
Start with a working local interface on port 5000, then create a Localtonet HTTP tunnel to reach it remotely without opening an inbound router port. Keep the device token private, apply application-level access controls, and run the tunnel only for as long as remote access is needed.
Get Started Free →
