Features

Everything between the tray icon and the tunnel

Valenius has grown a lot. So this page starts with the six things you won’t get anywhere else, then one table that settles what’s free and what’s paid — and the full technical detail is underneath, folded away until you want it.

Key features

What you won’t find in the alternatives

Plenty of tools put a web panel in front of WireGuard®. These six are the reasons teams pick Valenius instead — and the first five are things the free panels structurally cannot do.

🔑

Connect without administrator rights

A privileged system service owns the tunnel; the user only talks to a tray app. Staff connect with one click on a locked-down laptop — no UAC prompt, no sudo, no shared admin password, and no private key a standard user could ever read.

Technical detail →
Pro

Zero-touch peer provisioning

Approve a device in the panel and it gets a key pair, a preshared key, an IP from the subnet and a finished config — nobody edits a .conf file, nobody restarts an interface. Delete the device and the peer disappears from the server too.

Technical detail →
🔀
Pro

A fallback port for hostile networks

Your server also answers on UDP 443 — the port hotel Wi-Fi and guest networks leave open because HTTPS lives there. Both ports stay live at once and the client retries on the fallback automatically. The “the VPN doesn’t work from here” ticket stops arriving.

Technical detail →
🛡️
Pro

MFA on the tunnel itself

Not just on the admin panel — on the VPN. A user’s session carries traffic only after a verified second factor, enforced server-side, per group, with push-to-approve as an alternative to typing a code. Machine-to-machine links are never interrupted.

Technical detail →
🤖
Pro

A REST API — and an MCP server for AI

Every admin action is scriptable over 50+ scoped REST endpoints with a public OpenAPI 3.1 spec, and the same surface is exposed as an MCP server. Ask an assistant to kill the tunnel on a stolen laptop; it becomes an ordinary, audit-logged API call.

Technical detail →

Self-hosted, AGPLv3, and European

Valenius runs on your own servers: keys, device data and logs never leave the company, because there is no vendor cloud to leak from. The core is AGPLv3, so your security team can read exactly what it does — and the vendor behind it is an EU GmbH, not a US CLOUD Act subject.

Security & trust →

Two more things that surprise people: the Community edition is genuinely free — no device limit, no trial clock — and Valenius manages the WireGuard® server you already run, from day one. No rip-and-replace, no migration project.

Wondering how that stacks up against wg-easy, WGDashboard, WireGuard Portal or WireGuard WebAdmin? See the feature-by-feature comparison →

Editions

What’s free, what’s Pro, what’s hosted

Community is the full platform: unlimited devices, all five client apps, central management, security and monitoring. Pro adds the server-side automation layer. Cloud is Pro with the server run by us.

Capability Community Self-hosted Pro Cloud by Stranto
Clients & end-user experience
Windows, Linux, macOS, Android & iOS client apps Yes Yes Yes
One-click connect without administrator rights Yes Yes Yes
Verified-connectivity check through the tunnel Yes Yes Yes
Simultaneous multi-VPN on desktop, QR pairing on mobile Yes Yes Yes
Automatic fallback on UDP 443 for restrictive networks No Yes Yes
Central management
Unlimited devices, users and customers Yes Yes Yes
Live presence, remote config push, per-device settings Yes Yes Yes
Audit log, connection history, redacted remote log collection Yes Yes Yes
Encrypted backup & restore of the whole deployment Yes Yes Yes
Automatic client updates served from your own backend Yes Yes Yes
Per-customer pre-configured installers (silent / MDM) Yes Yes Yes
Server-side liveness detection & remote Kill Tunnel No Yes Yes
Per-client traffic statistics & dashboards No Yes Yes
Server automation
Manages an existing WireGuard® server (manual config upload) Yes Yes Yes
Zero-touch peer provisioning via the Pro sidecar No Yes Yes
Automatic key, preshared-key and IP allocation No Yes Yes
Several isolated customers on one WireGuard® host No Yes Yes
One-click connectivity self-test, handshake-confirmed No Yes Yes
Zero-downtime appliance updates, auto-rollback, rollout rings No Yes Yes
Security & access control
Config encryption at rest + system-only file permissions Yes Yes Yes
OIDC + TOTP sign-in for the admin panel Yes Yes Yes
Fleet-wide remote API-key rotation Yes Yes Yes
AGPLv3 source you can audit yourself Yes Core Core
mTLS + internal CA between backend and WireGuard® servers No Yes Yes
Server-enforced MFA for VPN access (TOTP / push-to-approve) No Yes Yes
Monitoring & integrations
Prometheus metrics endpoint + official Zabbix template Yes Yes Yes
Per-gateway metrics — peers, handshake age, CPU, memory No Yes Yes
Management REST API + public OpenAPI 3.1 spec No Yes Yes
Built-in MCP server for AI assistants No Yes Yes
Operations, licence & support
Where the backend runs Your infrastructure Your infrastructure Stranto’s EU cloud
Hosting, updates and backups handled by Stranto No No Yes
Licence AGPLv3 AGPLv3 core + commercial Pro licence Included in the subscription
Support Community, via GitHub Included with the licence Included
Price Free, forever Contact us from €3.00 / endpoint / month

Cloud by Stranto contains every Pro capability — the only difference is who operates the server. See full pricing and volume tiers →

For engineers

The long version — open what you need

Ten capability areas, each with its architecture and its specs. Nothing has been cut; it is simply folded away so the page stays readable.

Clients & end-user experience

One-click connect — without elevation

Client experience

A privileged system service owns the WireGuard® tunnel; users talk to it through a tray app over a local IPC channel that authenticates the calling user. No UAC prompts, no sudo, no shared admin password — and per-user profile separation built in.

After the tunnel comes up, Valenius probes your server through the tunnel and only flips to a green checkmark once the probe succeeds — so “connected” means verified end-to-end, not just “interface up”.

  • Per-user profiles — users see and manage only their own
  • Admin-pushed profiles are protected from deletion; user-uploaded ones are not
  • Auto-connect on unknown networks, with a trusted-network exclusion list
  • Verified-connectivity indicator (in-tunnel health probe)
  • Simultaneous multi-VPN on desktop — run your company VPN and a customer VPN at once, with automatic conflict detection
🖱️
Under the hood
  • Windows: system service + tray app · x64 & ARM64
  • Linux: systemd root daemon + GTK3 tray · .deb package
  • macOS: background daemon + menu bar app · Apple Silicon & Intel
  • IPC: named pipe / Unix socket, caller identity verified by the OS
  • Verification: HTTPS probe through the tunnel, retried up to 30 s

The same one-tap experience, now in your pocket

Client experience

The Android and iOS apps share one codebase, so they get the same connect/disconnect flow and the same verified-connection checkmark as the desktop clients — the app keeps showing your VPN profiles even through a brief connectivity blip, instead of flashing an error.

New devices are activated by scanning a QR code — no typing configs on a phone keyboard.

  • QR code pairing to activate and bind a new device in one step
  • TOTP and push-to-approve MFA built into the app (Pro)
  • Config encryption at rest via the platform keystore (Android Keystore / iOS Keychain)
  • One active VPN profile at a time — an OS-level limit on both Android and iOS, not a Valenius restriction; the app still shows and manages your full profile list
📱
Under the hood
  • Android: Flutter app · Android Keystore-backed encryption
  • iOS: same Flutter codebase & feature set as Android
  • Pairing: QR scan → device bound to a customer, no manual approval round-trip
  • Reconnect: profile list stays visible through brief connectivity blips (e.g. right after unlocking the phone)

Central management & operations

An admin panel that sees your whole fleet

Central management

Every client maintains a heartbeat plus a long-poll channel to your backend. A device shows online seconds after the user opens the tray app — and offline the moment they quit it, because the client actively signs off instead of waiting for a timeout.

  • Live online/offline presence and version per device
  • Push WireGuard® configs remotely — staged centrally, claimed by the device on its next poll
  • Per-device settings: heartbeat interval, auto-connect profile, trusted networks
  • Activate, deactivate, and remotely delete profiles centrally
  • Audit log of every connect, config push, and admin action
  • Self-service config delivery: QR codes for mobile, printable config cards, and email
  • Trigger a client to connect remotely — no user interaction required
  • Encrypted one-click backup & restore of the entire deployment
  • Server-side liveness detection & Kill Tunnel (Pro) — ping-confirmed status, and a forced disconnect that works even if the client is unreachable
  • Per-client connection history — connect/disconnect events with LAN/WAN IP
  • Per-client traffic statistics (Pro) — auto-refreshing dashboards per device, per customer, and fleet-wide, with configurable data retention
  • Redacted diagnostic log collection — request logs from a device centrally, or let the user send them; API keys, VPN keys, and secrets are stripped on the device before upload
Valenius admin panel Overview page: client counts, presence, and a fleet-wide traffic dashboard

The actual admin panel — live fleet overview

Under the hood
  • Presence: periodic heartbeat + long-poll · offline sign-off on exit
  • Config push: staged server-side, claimed atomically by the device
  • Sign-in: OIDC against your identity provider + TOTP 2FA
  • Identity: persistent device GUID; new installs need admin activation
  • Delivery: QR / printable card / SMTP email · encrypted JSON backup & restore
  • Liveness (Pro): backend-side ping against the WireGuard® server, independent of client self-reporting
  • Traffic (Pro): per-peer byte counters sampled server-side · charts auto-refresh every 60 s
  • Diagnostics: fixed per-platform allowlist · redaction runs on the device, never on the server

A fleet that updates itself

Operations

Clients check your backend — not a vendor server — for updates and install them automatically within the hour. Need it now? “Force update” in the panel triggers an immediate one-shot rollout on the next heartbeat. Every download is checksum-verified before a single byte is installed.

Pro appliances go further: the update agent starts the new version next to the running one, health-checks it repeatedly, swaps production only on success, and keeps watching afterwards — rolling back automatically if the new version misbehaves.

  • Automatic client updates served from your own backend
  • One-click forced rollout per device
  • SHA-256 verification before anything is written
  • Zero-downtime appliance updates with watchdog + auto-rollback (Pro)
  • Per-customer installer packages — backend URL & API key pre-baked, silent/MDM-ready
  • Staged rollout rings (Pro) — test a new appliance version on a subset of your fleet before going fleet-wide
  • Stable & beta release channels per OS — put pilot devices on beta, then promote beta to stable with one click
🔁
Under the hood
  • Clients: hourly update check + admin-triggered force update
  • Integrity: SHA-256 digest verified before install
  • Appliance: candidate container health-checked before the swap
  • Safety net: watchdog window with automatic rollback + volume backup
  • Deployment: pre-configured installer ZIP · silent install via /BACKENDURL= & /APIKEY=
  • Signing: Windows installers code-signed via Azure Trusted Signing

Server automation Pro

Zero-touch peer provisioning

Pro

A lightweight sidecar runs next to your WireGuard® interface and gives the backend a management API. Approve a device in the panel — it gets a key pair, an IP from the interface subnet, and a complete config, without anyone touching a .conf file.

Setup is one enrollment token: the sidecar generates its own private key, sends a signing request to your backend, and receives its certificate automatically. The token is one-time and consumed on use.

  • Automatic key generation, preshared keys, and IP allocation
  • Peers reconciled on startup — server reboots never lose configuration
  • Multiple isolated customers on one host (one interface + port each)
  • Removing a device in the panel removes the peer on the server
  • Opt-in cross-customer profile sharing — a device can also carry a second customer’s VPN profile, useful for MSPs on shared infrastructure
Under the hood
  • Sidecar: single static Go binary, stdlib only, Docker Compose deploy
  • Enrollment: one-time token → CSR → cert signed by the internal CA
  • IP allocation: automatic from the interface subnet (CIDR)
  • Interface: lives in the host network namespace — survives container restarts

One-click proof that a server is actually reachable

Pro

Before you tell a customer their VPN is live, the admin panel can verify it for you. “Check ports” tests every inbound port the WireGuard® host needs — the UDP ports are confirmed with a real WireGuard® handshake, not a ping, so a pass proves the port is reachable, the server’s key matches, and peer provisioning actually works.

“Run test” goes further and has the server inspect itself: IP forwarding, NAT, firewall forwarding rules, upstream routing, and configuration drift. That catches the single most confusing VPN failure — a tunnel that connects, shows as connected, and carries no traffic at all. Nothing observed from outside the server can detect that.

  • Check ports — per-port pass/fail, with UDP ports confirmed by a real WireGuard® handshake
  • Run test — the server inspects its own IP forwarding, NAT, firewall rules, routing, and configuration drift
  • Catches the “connected but no traffic” failure mode, invisible from outside the server
  • The panel names each required port and exactly who must reach it — including a warning that the management port isn’t meant to be public, with the backend’s own IP shown for a single-address firewall rule
🩺
Under the hood
  • Check ports: real WireGuard® handshake per UDP port, not a synthetic probe
  • Run test: self-inspection of IP forwarding, NAT, firewall forwarding rules, routing, and drift
  • Requires: backend 1.11.x + sidecar 1.11.24
  • Availability: Pro

A fallback port that keeps your team connected — even on networks that block VPNs

Pro

Every Pro-managed WireGuard® server can also answer on UDP 443 — the port that hotel Wi-Fi, guest networks, and locked-down corporate firewalls almost always leave open, because it’s where HTTPS lives. Both ports stay live at once, with a per-customer toggle in the admin panel, and clients retry automatically on the fallback port the moment a connection attempt is blocked — no manual profile edit, no support ticket.

It’s a resilience layer most WireGuard®-based competitors simply don’t offer, because it takes a real management plane on the server side to run two ports safely and hand a client the right one automatically. For your users, a restrictive network stops being a reason to call IT.

  • Server listens on the primary port and UDP 443 simultaneously — toggle it per customer from the admin panel
  • Automatic client-side retry on the fallback port after a blocked connection attempt — no manual reconfiguration
  • Solves the single most common “the VPN doesn’t work from this hotel/office” support call
  • A resilience feature most WireGuard®-based competitors don’t have — it takes a management plane on the server, not just the protocol
🔀
Under the hood
  • Ports: primary port + UDP 443, both live, toggled per customer
  • Client retry: triggered from the existing post-connect verification loop (~20 s without a handshake)
  • Scope: UDP 443 specifically — helps where networks filter by port number, not where all UDP is blocked or the protocol is fingerprinted
  • Requires: sidecar 1.11.24 (server) + current Valenius client

Security & access control

A management plane that assumes hostility

Security

Every call between your backend and your WireGuard® servers is mutually authenticated TLS: the backend runs its own internal certificate authority, and a server without a valid client certificate gets nothing but a health endpoint.

On end-user machines, configs are locked to the system account and encrypted at rest on every platform — in both editions. Standard users can connect, but can never read a private key; even direct disk access doesn’t expose one.

Pro can also gate the tunnel itself: server-enforced multi-factor authentication means a user’s VPN session only carries traffic after a verified second factor — a direct building block for NIS2-style access controls.

MFA is per-group, not all-or-nothing — stronger checks for admins, lighter for everyday staff. Instead of typing a code, users can approve a connection with a tap and Face ID/fingerprint on a second device. And it’s scoped to user access only: machine-to-machine and site-to-site connections are never interrupted.

  • Internal CA, mutual TLS on every management call
  • Config encryption at rest on every client — included in both editions
  • System-only file permissions on every client config
  • OIDC + TOTP for the admin panel, audit log for accountability
  • AGPLv3 open-source core — audit it yourself
  • Server-enforced MFA for VPN access — verified second factor before the tunnel carries traffic (Pro)
  • Push-to-approve from a second device, as an alternative to typing a TOTP code
  • Fail-safe enforcement — if the MFA component is out of date or unreachable, gated peers stay blocked rather than let through
  • Fleet-wide remote API-key rotation — roll the client credential across every device from the panel, without reinstalling anything
🛡️
Under the hood
  • mTLS: internal ECDSA P-256 CA, client certs verified per request and pinned to the backend’s identity
  • At rest: OS-level encryption of stored configs — both editions, every platform
  • File ACLs: SYSTEM-only on Windows, root-only (0600) on Linux
  • Audit: connects, config pushes, and admin actions recorded
  • MFA gating: CA-signed session grants with an absolute expiry, enforced on the VPN server’s own clock (Pro)
  • Enrollment: scan-a-QR TOTP setup, available in the Windows tray, Linux tray, and mobile app

Integrations & observability

Every admin action, available to your own tooling — and to an AI assistant

Automation & AI

Anything an administrator can do in the panel, Pro can also do over a scoped REST API: create and edit clients and customers, provision peers, connect or force-disconnect a device, set MFA policy, mint QR pairing codes, pull traffic and audit data. The OpenAPI 3.1 specification is served openly from your own backend, so Visual Studio, Postman, n8n or an RMM can import it from the URL and generate a typed client — no token needed just to read the spec.

The same surface is also exposed as an MCP server — the protocol Claude, Gemini, OpenAI and Mistral use to call external tools. Point an assistant at your backend and ask it in plain language: “which clients haven’t checked in this week?”, “kill the tunnel on that stolen laptop”, “onboard a new customer called Acme”. Underneath, every request is an ordinary API call — same token, same permissions, same audit entry.

Access is yours to shape. A token carries only the scopes you tick, so a triage assistant can be allowed to look at the fleet without being able to change a single thing; adding the right to act is a deliberate, separate decision. Bind a token to one customer and it can never see the others. Revocation is immediate, and every action is recorded under that token’s name in the audit log.

  • Full REST API over the whole admin surface (Pro) — 50+ endpoints
  • Built-in MCP server — connect Claude, Gemini, OpenAI or Mistral directly
  • Publicly readable OpenAPI 3.1 spec — import it into Visual Studio, Postman or any generator
  • Per-token scopes — read-only assistants are a first-class option, not a workaround
  • Optional per-customer token binding — an MSP can hand a tenant a token that only ever sees their own fleet
  • Every call audit-logged and instantly revocable
  • Works with n8n and other workflow tools — as an MCP tool or a plain HTTP request
🤖
Under the hood
  • REST: bearer-token auth, RFC 9457 problem details, per-token rate limiting
  • Spec: OpenAPI 3.1, generated from the running server so it never drifts
  • MCP: Streamable HTTP transport, 50+ tools, one per API operation
  • Scopes: read and write granted separately per resource family
  • Private keys: behind their own scope — never handed to an assistant by default

Your VPN on the same dashboard as everything else

Monitoring

Valenius exposes a Prometheus-compatible metrics endpoint, so the monitoring system you already run can watch the VPN the same way it watches your servers — is the backend up, is the database reachable, how much license runway is left, how many devices are online. It ships in both editions: observability is part of the open-source core, not a Pro upsell.

For Zabbix there is a finished, official template. One HTTP agent item polls once a minute and Zabbix’s own Prometheus preprocessing derives everything else from that single payload — around twenty control-plane and license items, plus per-gateway items and triggers that low-level discovery finds on its own. No agent on the backend, no script on the Zabbix server, and one request per minute no matter how large the fleet gets.

  • Official Zabbix template with triggers, discovery, value maps, a dashboard and a traffic graph
  • Backend health, database latency, request volume and p95 latency, 5xx rate, version changes
  • License validity, expiry and seat usage — warn at 30 days, escalate at 7
  • Per-gateway reachability, peer counts, oldest handshake, traffic, CPU/memory/load/conntrack (Pro)
  • A separate credential plane — a monitoring token can only read metrics, nothing else
  • Works with Prometheus, Grafana, Checkmk, VictoriaMetrics or anything else that scrapes Prometheus
  • Plain JSON health summary too, for Uptime Kuma or a curl check

See the monitoring & Zabbix page →

📊
Under the hood
  • Endpoint: GET /api/v1/metrics, Prometheus text exposition format
  • Auth: bearer token, single monitoring:read scope, optional CIDR allowlist
  • Cost: background snapshot with a 15 s cache — a scrape never blocks a request
  • Template: Valenius by HTTP, import-verified on Zabbix 7.4, declares 7.0
  • Privacy: opaque labels only — no hostnames, usernames, keys or client IPs

See it on your own infrastructure

The Community edition is free, self-hosted, and has every feature you just read about except the Pro automation.