Temporary internet sharing with Cloudflare Tunnel
OwnBase's Open to all button creates a
Cloudflare Quick Tunnel
from a random https://…trycloudflare.com address to the workspace on this
computer. It needs no Cloudflare account, domain, inbound firewall rule, port
forward, or public IP. cloudflared makes an outbound connection to Cloudflare;
friends use the public address while that connector is already running.
Install cloudflared#
The desktop app can install it for you: when it is missing, Manage hosting → Share on the internet offers Install cloudflared. OwnBase uses winget on Windows (for your account only, without an administrator) or Homebrew on macOS and Linux. Without either, or when that fails, it downloads Cloudflare's latest release from GitHub into its own folder, and keeps it only when it matches the SHA-256 digest GitHub publishes for it.
To install it yourself instead, use Cloudflare's official downloads, then check the installed version. On Windows, run these commands in PowerShell:
$msi = Join-Path $env:TEMP "cloudflared-windows-amd64.msi"
Invoke-WebRequest -Uri "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-amd64.msi" -OutFile $msi
Start-Process msiexec.exe -Verb RunAs -Wait -ArgumentList @("/i", "`"$msi`"")
Open a new PowerShell window and verify the installation:
cloudflared --version
On macOS with Homebrew:
brew install cloudflared
cloudflared --version
On Debian, Ubuntu, or another Debian-based distribution, use Cloudflare's package repository:
sudo mkdir -p --mode=0755 /usr/share/keyrings
curl -fsSL https://pkg.cloudflare.com/cloudflare-main.gpg | sudo tee /usr/share/keyrings/cloudflare-main.gpg >/dev/null
echo 'deb [signed-by=/usr/share/keyrings/cloudflare-main.gpg] https://pkg.cloudflare.com/cloudflared any main' | sudo tee /etc/apt/sources.list.d/cloudflared.list
sudo apt-get update && sudo apt-get install cloudflared
cloudflared --version
If cloudflared is elsewhere, set OWNBASE_CLOUDFLARED to its full path
before starting OwnBase.
Open and share the desktop workspace#
- In OwnBase, choose Host a workspace on this computer, open it, and create its owner account while it is still local.
- Open Manage hosting and select Open to all. Leave Require an invite link to create an account selected unless everyone who learns the public address should be able to create an account.
- Wait for OwnBase to show the
https://…trycloudflare.comaddress. The app starts and monitorscloudflared; a Cloudflare account is not required. - Open Workspace → Invite people, generate an invite, then choose Copy
link under Browser link. Send that complete link to a friend. It opens
the browser client with the invite code filled in; the friend does not
install
cloudflared. - Keep the host computer awake and keep OwnBase running. Close public link, Stop hosting, or quitting OwnBase ends the connector and makes that address unusable. Opening it again creates a different address, so send a new invite link.
The public HTTPS address carries the browser client, API requests, and WebSockets used for chat. Opening the invite link on another computer sends the request to Cloudflare's edge, which forwards it through the tunnel that the host already opened. A click cannot open a tunnel on a host that is offline. While that connector is active, the embedded server accepts Cloudflare's visitor-address header only from a loopback peer so its unauthenticated limits remain separate per visitor. It stops trusting that header as soon as the public link closes; LAN and other network peers cannot supply it.
Open to all adds Cloudflare's STUN service for peer-to-peer huddles. That is enough for most networks, but some, such as mobile data and strict office networks, will not let two people reach each other directly: chat works while their call stays on Connecting…. Calls between them need a TURN relay. Add one in Manage hosting, under Calls from other networks:
- Cloudflare: a TURN key's ID and API token, from the Realtime section of the Cloudflare dashboard. The token stays on the host computer, encrypted by the operating system; each call is given a password from Cloudflare that lasts a day.
- Another TURN server: its
turn:orturns:addresses, username and password. Everyone in a call is given that username and password.
Test checks that the relay gives this computer a route before anyone depends on it. A change reaches calls that start afterwards; a call stuck on Connecting… picks it up when it retries. If Cloudflare later refuses the key, the card says so.
Use an address you already have#
A Quick Tunnel gives a different address every time it opens, so every invite link has to be sent again. If something already carries a public HTTPS address to this computer, give that address to OwnBase instead and Open to all verifies and uses the same one every time.
Open Manage hosting, put the address under Your own address, and save. OwnBase starts no connector in this mode. It checks that the address reaches this workspace, publishes it into browser, invite and message links, and keeps checking while the link is open. OwnBase itself needs no domain or Cloudflare account for this mode, although the outside service you choose can have its own account or domain requirements.
The outside service remains in charge of public access. Close public link stops OwnBase from monitoring and putting the address into new links, but it cannot stop a Funnel, proxy, or tunnel that OwnBase did not start. As long as that service and the hosted workspace are running, the address remains reachable. Stop the outside service, or stop hosting, when the workspace must no longer be public. An old invite link keeps the stable base address, but its code can still expire or reach its use limit.
The carrier must forward every HTTP path and WebSocket upgrade to
http://127.0.0.1:<port>; forwarding only the home page is not enough for the
API or live chat. A Tailscale Funnel, a WebSocket-capable reverse proxy, a VPS
with a reverse tunnel, or another tunnel can do this. Use the actual port
Manage hosting shows for the workspace; it can differ from 8543 when that
port was already occupied.
Holding a port is not the same as owning it. On Windows a program already
listening on 127.0.0.1:8543 does not stop OwnBase binding 0.0.0.0:8543,
and loopback requests then go to that program rather than the workspace, so a
carrier forwarding there reaches the wrong thing. OwnBase checks this when
hosting starts and says so in Manage hosting; stop the other program and
start hosting again, or host on a different port. Open to all refuses
either way, because the address has to answer as this workspace before it is
published.
With Tailscale Funnel#
Tailscale Funnel gives a stable HTTPS name with a real certificate and no domain to buy. It is available on every Tailscale plan; Tailscale's Personal plan is free but is for non-commercial use, and caps how many people share a tailnet. That cap counts Tailscale accounts, not workspace members: a Funnel is open to the internet, so teammates join OwnBase through the address in a browser and need no Tailscale account at all. Funnel is currently beta and has non-configurable bandwidth limits. It also needs MagicDNS, HTTPS certificates, and the Funnel node attribute in the tailnet policy. The first command can open Tailscale's approval page to enable those settings; the person approving it needs the appropriate tailnet role.
Install Tailscale and sign in. On Windows, open PowerShell as Administrator and run the command with the port shown by OwnBase (8543 is only the usual value):
$port = 8543
tailscale funnel $port
That form runs in the foreground. Keep the PowerShell window open while people use the workspace, and press Ctrl+C to stop the Funnel. To let Tailscale keep it running in the background instead, use:
tailscale funnel --bg $port
Stop all Funnel routes on that computer when sharing is finished:
tailscale funnel reset
On Linux, use the same commands through sudo unless that user was configured
as Tailscale's operator:
port=8543
sudo tailscale funnel "$port"
# Or keep it in the background:
sudo tailscale funnel --bg "$port"
# Later, remove the public Funnel configuration:
sudo tailscale funnel reset
Funnel prints a name like https://box.tail1234.ts.net; paste it into Your own
address. The public HTTPS listener can use only port 443 (the default), 8443,
or 10000. The 8543 above is the local OwnBase target, not the public
listener. On macOS, forwarding a port needs one of the GUI builds — Tailscale
documents the Standalone system extension for this, and the open-source
tailscaled build is what its file-sharing rule is about, not ports. Check
which macOS variant you have
if tailscale funnel refuses the port.
OwnBase does not sign in to Tailscale or change the tailnet policy. Those steps belong to Tailscale's own client and approval page, and the Windows command needs Administrator rights. OwnBase takes only the finished public address; it never receives Tailscale account credentials.
Setting it outside the app#
OWNBASE_PUBLIC_URL sets the same address from the environment, for a
service or a scripted install. An address set
that way is shown in Manage hosting but cannot be edited there, since the
app does not own it. A saved address takes precedence over both, so an old
variable in a shell cannot quietly replace one somebody typed into the app.
The address has to be a public HTTPS origin, the same rule described below. If it stops answering as this workspace, OwnBase gives it up after several checks in a row fail, removes it from new links, and says so in Manage hosting. A brief network blip does not invalidate the links you have sent. This does not shut down the outside carrier; use its own stop command when the address itself must stop accepting connections.
A stable address OwnBase runs for you#
If you own a domain on Cloudflare, OwnBase can run the connector itself rather than leaving it to you. Open to all then starts and stops a Cloudflare named tunnel with the workspace, at an address that does not change. This needs a domain; the section above needs none.
Create a remotely managed tunnel in Cloudflare's
Tunnels dashboard, then add a Published
application route whose hostname is your public address and whose service URL is
http://127.0.0.1:8543, replacing 8543 with the port Manage hosting shows.
Do not use cloudflared tunnel create for this flow: that command creates a
locally managed tunnel with a credentials JSON file, while OwnBase's
--token-file flow requires a remotely managed tunnel.
In the tunnel's dashboard page, choose Add a replica and copy the connector
token (the eyJ… value in Cloudflare's installation command) into a file
readable only by your account. OwnBase never reads its contents; it passes
the path to cloudflared --token-file.
That option requires cloudflared 2025.4.0 or later, so check
cloudflared --version and update it first when needed.
Environment variables belong to the process that starts OwnBase. On Windows, set both in PowerShell and launch the installed app from that same window so it inherits them:
$env:OWNBASE_TUNNEL_URL = "https://chat.example.org"
$env:OWNBASE_TUNNEL_TOKEN_FILE = "C:\Users\sam\.cloudflared\chat-token.txt"
Start-Process "$env:LOCALAPPDATA\Programs\OwnBase\OwnBase.exe"
If OwnBase was installed elsewhere, replace the last path with the path to
its OwnBase.exe. To launch it later from the Start menu, save the two values
as user environment variables first, then sign out and back in so newly launched
apps inherit them. The token itself stays in the protected file; the environment
contains only its path.
On Linux, export the values and run the AppImage from that same shell:
export OWNBASE_TUNNEL_URL=https://chat.example.org
export OWNBASE_TUNNEL_TOKEN_FILE=/home/sam/.cloudflared/chat-token
./OwnBase-0.2.0.AppImage
The same inheritance rule applies on macOS: a GUI app opened from Finder or the Dock does not inherit variables exported in an unrelated terminal. Start its executable from the configured shell or provide the values through the service or launcher that owns the app process. Releases include no Linux package, and CI neither builds nor tests one.
OWNBASE_TUNNEL_URL has to be a public HTTPS origin: a hostname with a dot,
and no path, query, credentials, or fragment. Loopback and private-network
suffixes (.local, .internal, .home, .lan, localhost) and bare IP
addresses are refused, and so is a trailing dot. An accented hostname is
accepted and stored in its punycode form. A non-standard HTTPS port is allowed,
for the alternate ports Cloudflare proxies. Setting only one of the pair, naming
a token file that is not there, or giving an address that cannot be published
is reported in Manage hosting and leaves Open to all unavailable, rather
than quietly opening a temporary address nobody was given. Environment variables
are read when the app launches, so fully quit and restart OwnBase from the
correct environment after changing them. After installing cloudflared or
creating a missing token file, reopen Manage hosting (or use Check again
when shown) to refresh the status.
Open to all then starts the saved connector and waits until the configured address reaches this running workspace before publishing it. If the address answers as something else — another workspace, or a route left pointing somewhere old — opening fails and says which Cloudflare route to correct. What the connector prints is kept out of OwnBase's messages and logs, because it can quote the token it was given.
Closing the public link or quitting stops the connector, and the address stops working until it is opened again. Unlike a Quick Tunnel, the address itself survives, so invite links already sent keep working the next time you open it.
Run a Quick Tunnel with the standalone server#
Build the server first, start it only on the local interface, and create the owner account before exposing it:
pnpm install
pnpm build
node apps/server-cli/dist/ownbase-server.js --data ./data --name "My Team" --host 127.0.0.1 --invite-only
Open http://127.0.0.1:8543, create the owner, then stop the server with
Ctrl+C. In one terminal, start a Quick Tunnel and keep it running:
cloudflared tunnel --url http://127.0.0.1:8543
Copy the https://…trycloudflare.com address it prints. In a second terminal,
set the STUN configuration and restart the same data directory with that exact
address. On macOS or Linux:
export OWNBASE_ICE_SERVERS='[{"urls":"stun:stun.cloudflare.com:3478"}]'
node apps/server-cli/dist/ownbase-server.js --data ./data --name "My Team" --host 127.0.0.1 --invite-only --public-url https://YOUR-RANDOM-NAME.trycloudflare.com
Or in PowerShell:
$env:OWNBASE_ICE_SERVERS='[{"urls":"stun:stun.cloudflare.com:3478"}]'
node apps/server-cli/dist/ownbase-server.js --data ./data --name "My Team" --host 127.0.0.1 --invite-only --public-url https://YOUR-RANDOM-NAME.trycloudflare.com
Sign in through the public address, open Workspace → Invite people, and send
the copied browser invite link. Stop the server and cloudflared with Ctrl+C
when finished. The STUN setting is optional for chat; it has the same no-TURN
limitation described above.
Quick Tunnel limits#
Cloudflare describes Quick Tunnels as a testing and development feature. They have no SLA, give a random address for the life of the process, and are limited to 200 concurrent in-flight requests. WebSockets work, which is what OwnBase chat uses, but Server-Sent Events do not. See Cloudflare's Quick Tunnel documentation and Tunnel FAQ for the current limits. Use a named tunnel, your own domain, and a supervised server process for a stable deployment; Cloudflare documents that flow under Create a locally-managed tunnel.
Cloudflare also says Quick Tunnels are unsupported while a
.cloudflared/config.yaml file is present. If cloudflared refuses to create
the temporary link for that reason, temporarily move that file aside, retry,
and restore it before using its named-tunnel configuration again.