SSD Nodes Learn Hosting plans →
Guides Matt ConnorBy Matt Connor

Does Tailscale limit bandwidth? Path by path

Tailscale's plans list no data cap, but each path differs: direct, DERP relay, Funnel or exit node. See which path you are on and how to make it faster.

Does Tailscale limit bandwidth?

Tailscale does not publish a bandwidth cap for traffic between your own devices. Its pricing page lists limits on users, ACL (access control list) groups, tagged resources and ephemeral-resource minutes. It lists no limit on data transfer or throughput, on any plan. The limits you actually hit depend on the path your packets take: a direct connection, a DERP relay, Funnel, or an exit node.

So the question has four answers, one per path. This guide covers each path. Then it shows how to tell which path a connection is on, and gives the fixes in the order to try them.

Path 1: direct connections between your own devices

A direct connection is a peer-to-peer UDP connection between two devices in your tailnet, which is your private Tailscale network. The packets go from one device straight to the other. Tailscale's docs say direct connections usually give the lowest latency and the highest throughput.

Here is what the plans say, as read on 21 November 2026. The free Personal plan allows up to 6 users, and user devices are free and unlimited on every plan. Every use of "unlimited" on the pricing page is about devices or users. None is about data or bandwidth. The page lists no data cap, but it does not promise unlimited bandwidth either, so read it as "no cap listed" and nothing more. The user, tag and group limits for each plan are in what the free Tailscale Personal plan includes and limits.

On a direct path, the speed comes from the two devices and the networks between them. CPU is part of that, because every packet is encrypted on one side and decrypted on the other. Tailscale's performance guidance says that a higher CPU clock speed matters more than more cores.

Path 2: traffic relayed through DERP servers

DERP (Designated Encrypted Relay for Packets) servers are relays that Tailscale operates. Every connection starts out relayed through a DERP server. Tailscale then tries to upgrade it to a direct connection. If the upgrade fails, the traffic stays on DERP.

Tailscale publishes no throughput number for DERP and documents no rate limit, so do not trust any figure you see quoted for it. What the docs do say is qualitative. DERP servers have limited quality of service, so they "are generally slower than direct connections and may offer lower maximum throughput". The same page says that using a relayed connection when a direct one would be possible is one of the most common causes of performance problems.

That gives you the practical rule. When a tailnet feels slow, check first whether the connection is relayed.

Path 3: Funnel, the one path with a stated limit

Funnel publishes a service on one of your devices to the public internet. It is the only path where Tailscale states a bandwidth limit outright. The Funnel docs say traffic sent over a Funnel is subject to "non-configurable bandwidth limits", and they give no figure. The ports Funnel listens on, the TLS (transport layer security) requirement and its beta status are covered in Tailscale Funnel limits and ports.

Because the limit is not configurable, no setting raises it. A public service that must move a lot of traffic needs a public IP and an ordinary reverse proxy instead.

Path 4: exit nodes run at the node's speed

An exit node carries your internet traffic for you. Your device sends packets to the exit node over the tailnet. The exit node then sends them to the internet over its own connection. That is two legs. The first leg is a normal tailnet path, direct or relayed. The second leg runs at the speed of the exit node's own uplink.

The direction matters. When you download through an exit node, every byte you receive is uploaded to you by the exit node. So an exit node on a home line with a slow upload limits how fast every device behind it can download.

Tailscale's exit-node page gives no throughput figure. It does warn about platforms. An Android exit node may be too slow for most cases. Exit node support on macOS is new and still being optimised. On Windows the exit node is implemented in userspace, which differs from the default Linux implementation. A Linux VPS with a fast uplink avoids these problems, and the setup is in how to run a Tailscale exit node on a VPS.

Tune a Linux exit node or subnet router

Tailscale 1.54 or later, on a Linux 6.2 or later kernel, can use transport layer offloads to improve UDP throughput. Tailscale's performance guide turns them on with ethtool, on the network interface that carries the default route. Check both versions first:

tailscale version
uname -r

The first line of tailscale version must be 1.54 or higher, and uname -r must start with 6.2 or higher. Then apply the setting:

sudo apt install -y ethtool
NETDEV=$(ip -o route get 8.8.8.8 | cut -f 5 -d " ")
echo "$NETDEV"
sudo ethtool -K "$NETDEV" rx-udp-gro-forwarding on rx-gro-list off
ethtool -k "$NETDEV" | grep -E 'rx-udp-gro-forwarding|rx-gro-list'

echo should print a real interface name such as enp1s0 or ens3. The last command should show rx-udp-gro-forwarding: on and rx-gro-list: off. By default, changes made with ethtool do not persist after a reboot. The setting is gone after the next reboot unless you apply it again at boot.

Tailscale gives no measured gain for this change, so measure it yourself. Run iperf3 -s on the exit node, then iperf3 -c <exit node tailnet IP> from a client, once before the change and once after.

How to tell which path a connection is on

Three commands answer the question. Run them on the device that feels slow. The sample output below is adapted from Tailscale's own docs, so your names and addresses will differ.

Read the connection type in tailscale status

The connection type only shows for a peer that is passing traffic. Send some traffic to the peer first, for example with tailscale ping, and then run:

tailscale status
100.113.160.82  device-a     tagged-devices  linux    active; offers exit node; direct 10.0.0.5:41641
100.104.93.78   localhost-0  user@           android  active; relay "tor"

active means traffic is flowing to or from that device right now. After it comes the connection type. direct is followed by the peer's real IP address and port. relay is followed by the city code of the DERP server in use, here tor. A third type, peer-relay, means the traffic goes through one of your own peer relays (see the fixes below). idle means no traffic right now, and - means no traffic has ever been sent to that device.

Watch tailscale ping upgrade, or fail to

tailscale ping device-a

tailscale ping sends pings only over Tailscale, not over the normal network. It sends at most 10 pings by default, and it stops as soon as a direct path exists. A healthy run starts on DERP and then switches:

pong from another-device (100.113.160.82) via DERP(nyc) in 130ms
pong from another-device (100.113.160.82) via 10.0.0.5:41641 in 35ms

The first packets go through the nearest DERP server while Tailscale negotiates a direct connection. The second line shows a real IP and port, so the path is now direct. A connection that never upgrades stays on DERP and ends with a clear message:

pong from another-device (100.104.93.78) via DERP(tor) in 53ms
direct connection not established

Traffic through a peer relay shows the relay's address instead:

pong from another-device (100.97.143.93) via peer-relay(192.168.64.2:7777:vni:1) in 4ms

Check the network with tailscale netcheck

tailscale netcheck

This reports on the physical network the device sits on. Two lines in the report matter most:

* UDP: true
* MappingVariesByDestIP: false

UDP: false means UDP is blocked on this network, so a direct connection is unlikely. MappingVariesByDestIP: true means the device is behind a difficult NAT (network address translation) that changes the device's public IP address depending on the destination. Tailscale calls this the most important field for working out why a device is not using direct connections. The report also lists the nearest DERP region and the latency to each region. Run netcheck on both ends, because either side's network can block the direct path.

How to fix a slow relayed connection, in order

1. Get a direct path first

A direct path costs nothing extra and is usually the fastest, so try it before anything else. Most relayed connections come from a firewall that blocks UDP, or from a difficult NAT on one side. The step-by-step diagnosis is in why Tailscale is slow on relayed connections, and the ports to open are in Tailscale ports and firewall rules. After each change, run tailscale ping again and look for the line with a real IP and port.

2. Use Tailscale Peer Relays

When a direct path is impossible, for example because a strict network blocks it, a peer relay is the next step. A peer relay is a device in your own tailnet that relays traffic between other devices. Tailscale announced Peer Relays as generally available on 18 February 2026, and says they are available on all plans, including the free Personal plan.

Tailscale uses a peer relay first when one is available, and falls back to DERP when none is. Its docs say peer relay connections are usually faster than DERP, because they avoid routing traffic through a DERP server that may be far away. They give no throughput figure. Peer relays do not replace DERP. They sit in front of it.

A VPS with a public IP makes a good relay. Peer relays need Tailscale 1.86 or later on the relay and on the other tailnet devices, so check tailscale version on every device involved. On the relay, pick a UDP port, enable the relay on it, and open that port in the firewall:

sudo tailscale set --relay-server-port=40000
sudo ufw allow 40000/udp

Then allow devices to use the relay with a grant in your tailnet policy file. The relay capability takes no parameters. In this example from Tailscale's docs, src holds the devices that may use the relay and dst holds the relay itself:

"grants": [
  {
    "src": ["tag:us-east-vpc"],
    "dst": ["tag:us-east-relays"],
    "app": {
      "tailscale.com/cap/relay": []
    }
  }
]

Run tailscale ping between two devices that were relayed before. A line with via peer-relay(...) means the relay is in use. A relay receives every byte and sends it on again, so its own bandwidth allowance is the ceiling for that traffic. The docs also list an optional --relay-server-static-endpoints flag that sets fixed ip:port endpoints for the relay. To turn the relay off, run sudo tailscale set --relay-server-port="".

3. Run your own DERP server on a VPS

Tailscale's docs say that in most cases you do not need a custom DERP server, and they point to peer relays instead. Custom DERP servers are also still labelled alpha. Take this route only when you want a relay of last resort that you control, close to your users.

The server must sit directly on the internet, not behind NAT or a load balancer. It must allow ICMP. It needs port 80 for HTTP (this port cannot be changed), port 443 for HTTPS and UDP port 3478 for STUN. Point a DNS name at the VPS first. Install Go from the Go download page, then build and start derper:

go install tailscale.com/cmd/derper@latest
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 3478/udp
sudo "$(go env GOPATH)/bin/derper" --hostname=derp.example.com --verify-clients

--verify-clients lets only your own tailnet use the relay. It works only when tailscaled runs on the same machine, so install Tailscale on the VPS and join it to your tailnet first. Without that flag, the relay does not check whether a client belongs to your tailnet.

Then add the server to your tailnet policy file under derpMap. Region IDs 900 to 999 are reserved for custom regions, and each region can hold only one DERP server:

"derpMap": {
  "Regions": {
    "900": {
      "RegionID": 900,
      "RegionCode": "myderp",
      "Nodes": [
        {
          "Name": "1",
          "RegionID": 900,
          "HostName": "derp.example.com"
        }
      ]
    }
  }
}

This adds your region next to Tailscale's own. Setting a default region to null disables it, and "OmitDefaultRegions": true removes all of them. Avoid that with a single server. Your one VPS would then be the only relay, so relayed connections have nowhere to go when it is down. Run tailscale netcheck afterwards and look for your region among the DERP latencies.

Know the costs before you commit. Custom DERP servers do not support device sharing or other cross-tailnet features, and Mullvad exit nodes do not work with them. You also need to rebuild derper from time to time with the same go install command. If you want the whole control plane on your own hardware too, Headscale, the self-hosted Tailscale control server is the next step up.

FAQ

Does the free Tailscale plan have a data or bandwidth cap?

Tailscale's pricing page lists no data, bandwidth or throughput cap on any plan, including the free Personal plan. The limits it does list are on users, ACL groups, tagged resources and ephemeral-resource minutes. The page also never says bandwidth is unlimited. "Unlimited" there refers to user devices and users. The one documented bandwidth limit is on Funnel, which is subject to non-configurable limits with no published figure.

How fast is a Tailscale DERP relay?

Tailscale publishes no number. Its docs say DERP servers have limited quality of service, so they are generally slower than direct connections and may offer lower maximum throughput. Run tailscale ping <peer>. If the output stays on via DERP(...) and ends with direct connection not established, the connection is relayed. Fix the direct path first, then consider a peer relay.

Why is my exit node slow when direct connections are fast?

Exit node traffic has a second leg: from the exit node to the internet, over the node's own uplink. When you download through it, the exit node uploads every byte to you, so a slow upload on the node's line limits your download speed. The node's platform also matters. Tailscale warns that an Android exit node may be too slow for most cases, that macOS support is still being optimised, and that Windows exit nodes run in userspace, unlike the default Linux implementation. A Linux VPS with a fast uplink avoids both problems.

Do I need my own DERP server to get faster relayed connections?

Usually not. Tailscale's docs say that in most cases there is no need for a custom DERP server, and they suggest peer relays instead. Peer relays are generally available on all plans, need Tailscale 1.86 or later, and are usually faster than DERP. A custom DERP server is still alpha, does not support device sharing, and does not work with Mullvad exit nodes.

Was this article useful?