Managed Nebula vs Headscale

Last updated:

Abstract dark teal and purple gradient

Managed Nebula and Headscale both answer the same question: how do you get a secure mesh network without handing the control plane to a vendor? They arrive at very different answers. Managed Nebula runs the control plane for you on top of a fully open-source data plane. Headscale lets you run the control plane yourself, using the official Tailscale clients.

Nebula is a fully open-source overlay networking tool that we originally built at Slack and continue to maintain at Defined Networking. It uses its own protocol built on the Noise framework to create peer-to-peer encrypted tunnels between hosts. Managed Nebula is our cloud-hosted management layer that handles certificate authorities, host configuration, and distribution, while your traffic stays encrypted end-to-end between your hosts.

Headscale is an open-source, self-hosted implementation of the Tailscale control server. It acts as the exchange point for WireGuard public keys, assigns client IP addresses, and distributes routes and access policy to the Tailscale clients on your nodes. It is a community project, not associated with Tailscale Inc., and its maintainers describe its target audience as self-hosters, hobbyists, and small open-source organizations.

If you are weighing Headscale, you have probably already looked at Tailscale. Our Managed Nebula vs Tailscale comparison covers the protocol, firewall, and performance differences between Nebula and WireGuard-based meshes in depth. This page focuses on what changes when the control plane is one you host yourself.

At a glance

Managed NebulaHeadscale
ProtocolNebula (Noise IX)WireGuard (Noise IK)
Control planeHosted by Defined NetworkingSelf-hosted by you
ClientsDNClient (Defined-maintained)Official Tailscale clients
AuthenticationCertificate-based (Nebula CA)Pre-auth keys, web auth, OIDC
Access controlStateful firewall, group-basedTailscale ACL policy, HuJSON
NAT traversalLighthouses + relays (UDP)DERP (TCP) + peer relays
Admin interfaceWeb admin panel and APICLI and API; web UIs are third-party
Open sourceData plane MIT; control plane oursBSD-3-Clause, entire server
Target scaleSmall teams to large fleetsPersonal use and small organizations
SupportEmail, priority, and Slack channelsCommunity Discord
CostFree to 100 hosts, then $1/host/moFree software, your server and time

Architecture

Both tools produce a mesh where hosts talk directly to each other whenever they can. The difference is in what each host depends on to find and trust its peers.

Nebula uses its own protocol built on the Noise IX handshake pattern. Every host holds a certificate signed by a Nebula Certificate Authority that encodes its overlay IP, name, and group memberships. Two hosts validate each other’s certificates directly, so the data plane needs no central server to authorize a connection. Managed Nebula signs and rotates those certificates and pushes configuration to hosts. If our management service goes offline, existing hosts keep their certificates and keep establishing new tunnels through lighthouses, which run independently of it.

Headscale reimplements the Tailscale control server. Tailscale clients register with it, receive a WireGuard key map of every peer they are allowed to reach, and get updates whenever anything in the network changes. Traffic flows peer to peer over WireGuard, but discovery, key distribution, and policy all come from the Headscale server. When that server is unavailable, established sessions continue, but new nodes cannot join and policy changes do not reach anyone until it returns.

In other words, Headscale changes who runs the Tailscale control plane, not how much the network depends on it.

Running the control plane

This is the real decision between the two.

With Headscale, you operate everything: the server binary, its database, TLS certificates, upgrades, backups, and the DERP relays that carry traffic when NAT traversal fails. Headscale ships an embedded DERP server and by default can also use Tailscale’s public DERP map, so you can start without hosting relays and bring them in-house later. The maintainers recommend SQLite over PostgreSQL, which is in maintenance mode. They do not officially support running Headscale in containers and do not use reverse proxies with it themselves, though community guides exist for both. Upgrades go one minor version at a time.

Headscale has no bundled web interface. Day-to-day administration happens through the headscale command and its gRPC and REST API. Several community projects provide a web UI on top of it.

With Managed Nebula, we run the control plane, a managed lighthouse, and relays on day one, and you administer the network from a web admin panel or the API. You can also run your own lighthouses and relays, on-premise or in your own cloud, so overlay traffic and discovery never leave infrastructure you control. Mixing the two gives you redundancy: host your own lighthouse and the overlay keeps working through an Internet outage, with ours as a fallback.

If your reason for choosing Headscale is “I don’t want a vendor in the data path,” note that Managed Nebula does not put one there either. Our management service signs certificates and distributes config. It never sees or carries your traffic, and the lighthouses and relays can be yours.

Authentication

Nebula uses certificate-based authentication. Each host presents a certificate signed by the network’s CA, and peers validate it against the CA on every handshake. Adding a host means signing one more certificate; no other host needs to be reconfigured. Managed Nebula handles the CA, enrollment, and rotation, and supports single sign-on for host enrollment on every plan, including the free tier.

Headscale registers nodes the way Tailscale does: a web login flow, a pre-authenticated key for unattended installs, or an OpenID Connect provider for single sign-on. Node identity is a WireGuard public key that the server has approved. OIDC covers registration and user profiles, but Headscale’s documentation notes that OIDC groups cannot be used in access policy.

Firewall and access control

Nebula has a stateful packet firewall built into the Nebula process on every host. Because certificates carry group membership, rules reference groups rather than IP addresses, in the style of AWS Security Groups:

firewall:
inbound:
- port: 5432
proto: tcp
groups:
- WebApp

Managed Nebula turns these into roles and tags you edit in the admin panel, and each host enforces its own rules even when the control plane is unreachable.

Headscale uses Tailscale’s ACL policy format, a HuJSON document you load into the server. It supports ACLs, grants, tags, auto-approvers for subnet routers and exit nodes, Tailscale SSH rules, and some autogroups. Policy is enforced by the Tailscale client on each node, and the server recomputes and redistributes the peer map whenever the policy or the network changes. An invalid stored policy prevents the server from starting until it is fixed.

Both approaches give you identity-based, stateful filtering, which is more than most self-hosted WireGuard tooling offers.

NAT traversal

Nebula hosts register their addresses with lighthouses and hole-punch directly to each other. When a direct path is impossible, traffic goes through a relay over UDP at full throughput. Managed Nebula runs both lighthouses and relays for you, and you can run your own.

Headscale inherits Tailscale’s approach: direct WireGuard connections when possible, DERP relays over TCP as the fallback, and peer relays over UDP on nodes you host. DERP works even where UDP is blocked, but at lower throughput. With Headscale, every DERP server is either Tailscale’s public infrastructure or one you run.

Scale and performance

Headscale’s maintainers are candid about this in their FAQ: performance is not a design priority. The server recomputes a full map of the network for every node whenever anything changes, so a large, mostly static fleet can work, but a network with many laptops and phones roaming between networks keeps that work queued, and in the worst case the backlog never clears. They also say plainly that Headscale is not enterprise software.

Nebula’s data plane was built for Slack’s production fleet and is the subject of an ongoing public benchmarking effort. In our testing it saturates a 10 Gbps link, averages around 27 MB of memory per host, and shows very consistent throughput run to run. Managed Nebula’s control plane is operated and scaled by us.

Open source

Headscale is entirely open source under the BSD-3-Clause license. Its data plane is WireGuard, and its clients are Tailscale’s open-source clients. One of its maintainers is employed by Tailscale and may contribute on work time, but the project is independent, and features that Tailscale ships in its proprietary server, such as Funnel and network flow logs, are tracked as open issues rather than guaranteed.

Nebula is fully open source under the MIT license: the protocol, the firewall, the lighthouse, the relay, and the certificate tooling. You can run a complete Nebula network with no dependency on us. Managed Nebula’s control plane is our hosted service on top of that, and DNClient, the client that talks to it, is maintained by the same team that maintains Nebula.

The trade is clear. Headscale gives you an open-source control plane you must operate. Managed Nebula gives you an open-source data plane with a control plane you don’t have to.

Pricing

Managed Nebula offers simple per-host pricing:

  • Free: Up to 100 hosts, 2 routes, SSO, and the admin panel. No credit card required.
  • Pro: $1/host/month with unlimited hosts, up to 100 routes, priority support, and guaranteed uptime.
  • Enterprise: Custom pricing with a dedicated Slack support channel and network design assistance.

See our pricing page for full details, or contact sales for Enterprise.

Headscale is free software. The cost is a server to run it on, the DERP relays you host, backups, upgrades, and the engineering time to own all of it. There is no paid support tier; help comes from the documentation and the community Discord. For a homelab that cost is close to zero. For a team that needs someone on call when enrollment stops working, it is the main line item.

Which is right for you?

Choose Managed Nebula if you want:

  • A control plane someone else operates, with the option to self-host lighthouses and relays
  • A network that keeps running when the control plane is unreachable
  • Group-based firewall rules that scale without reconfiguring every host
  • Consistent, low-overhead performance across a large or frequently changing fleet
  • A web admin panel, audit logs, and an API without assembling third-party tools
  • Paid support and an uptime guarantee when you need them

Choose Headscale if you want:

  • Every component, including the control server, running on your own hardware
  • To keep using the official Tailscale clients and workflows your team already knows
  • WireGuard as the tunnel protocol
  • MagicDNS, exit nodes, Taildrop, and Tailscale SSH on a self-hosted server
  • A personal or small-organization network where operating it yourself is part of the appeal

Headscale details verified against the v0.29 documentation, November 2026.


Frequently asked questions

Is Headscale free?

Yes. Headscale is open source under the BSD-3-Clause license and costs nothing to run. The cost is the server you host it on, the time to operate and upgrade it, and the absence of a support contract. Managed Nebula is free for up to 100 hosts, with the control plane, a lighthouse, and relays run for you.

Can I use Headscale for a business?

Commercial use is allowed by the license, but the maintainers describe Headscale as not enterprise software, built for self-hosters, labs, and small open-source organizations. Managed Nebula is built for teams and offers paid support and an uptime guarantee.

Does Headscale work with the official Tailscale apps?

Yes. Headscale reimplements the Tailscale control server, so you keep using the official Tailscale clients and point them at your own server. Nebula uses its own client, DNClient, which Defined Networking builds and maintains alongside the open-source Nebula project.

What happens if the control plane goes down?

With Headscale, nodes keep their existing WireGuard sessions, but new nodes cannot join and policy changes do not reach anyone until it returns, and there is no managed fallback because you run it. With Managed Nebula, hosts keep their certificates and keep connecting through lighthouses that run independently of our management service.


Related comparisons

Encryption that works

Fast, secure overlay networking with unlimited scalability. Up to 100 hosts free, no credit card required.

Get started