SYNCTHING-RELAY(7)

📦

version 2.1.7 · 10 versions

2.1.7 · arch rolling, nixos 26.05, nixpkgs unstable (latest)
2.1.0 · alpine 3.24
2.1.6 · epel 10, fedora 43, fedora 44
1.18.0 · ubuntu jammy
1.30.0 · fedora 43
2.1.3 · fedora 44
2.0.14 · fedora 44
1.27.2 · ubuntu noble
1.19.2 · debian bookworm
1.29.5 · debian trixie, ubuntu questing, ubuntu resolute, ubuntu stonking

, in arch rolling, nixos 26.05, nixpkgs unstable

💅 syncthing-relay(7) — Relay Protocol v1

🏷️ NAME

syncthing-relay — Relay Protocol v1

🌐 WHAT IS A RELAY? 💖

Okay so bestie, a relay is literally a service that relays data between two devices that are not able to connect to each other directly otherwise. Usually this happens because both devices are behind a NAT and neither side can open a port that would be directly accessible from the internet. 😭

A relay was designed to relay the BEP protocol, which is why the protocol spec leans on device IDs, but at the same time it’s general enough that it could be reused by other protocols or applications. Why? Because the data transferred between two devices that use a relay is completely obscure and does not affect the relaying. ✨

🔀 OPERATION MODES ✨

Relay listens on a single TCP socket, but it has two different connection modes, where a connection mode is a predefined set of messages that the relay and the device are expecting to exchange. 👑

The first mode is protocol mode, which lets a client interact with the relay — for example, join the relay, or request to connect to a device, given it is available on the relay. Similarly to BEP, protocol mode requires the device to connect via TLS using a strong suite of ciphers (same as BEP), which allows the relay to verify and derive the identity (Device ID) of the device. 🔐

The second mode is session mode, which after a few initial messages connects two devices directly to each other via the relay, and is a plain-text protocol. For every byte written by one device, it sends the same set of bytes to the other device and vice versa. 🫶

🕵️ IDENTIFYING THE CONNECTION MODE 👀

Because both connection modes operate over the same single socket, a method of detecting the connection mode is required. No cap. 💅

When a new client connects to the relay, the relay checks the first byte that the client has sent, and if that matches 0x16, that implies to us that the connection is a protocol mode connection, due to 0x16 being the first byte in the TLS handshake, and only protocol mode connections use TLS. 🎀

If the first byte is not 0x16, then we assume that the connection is a session mode connection. Simple as that. ✨

🛰️ PROTOCOL MODE 💅

Protocol mode uses TLS and the protocol name defined by the TLS header should be bep-relay. 📡

Protocol mode has two submodes:

Permanent protocol submode — Joining the relay, and waiting for messages from the relay asking to connect to some device which is interested in having a session with you. ♾️
Temporary protocol submode — Only used to request a session with a device which is connected to the relay using the permanent protocol submode. ⏳

♾️ Permanent protocol submode

A permanent protocol submode begins with the client sending a JoinRelayRequest message, which the relay responds to with either a ResponseSuccess or ResponseAlreadyConnected message if a client with the same device ID already exists. 🫡

After the client has joined, no more messages are exchanged apart from Ping/Pong messages for general connection keep alive checking. 💓

From this point onwards, the client stand-by’s and waits for SessionInvitation messages from the relay, which implies that some other device is trying to connect with you. The SessionInvitation message contains the unique session key which then can be used to establish a connection in session mode. 🔑

If the client fails to send a JoinSessionRequest message within the first ping interval, the connection is terminated. If the client fails to send a message (even if it’s a ping message) every minute (by default), the connection is terminated. 💀

⏳ Temporary protocol submode

A temporary protocol submode begins with a ConnectRequest message, to which the relay responds with ResponseNotFound if the device the client is after is not available, with a RelayFull if the relay has reached its limits, or with a SessionInvitation, which contains the unique session key which then can be used to establish a connection in session mode. 🌸

The connection is terminated immediately after that. 🙈

📨 Example Exchange

Client A - Permanent protocol submode Client B - Temporary protocol submode

┌────┬────────────────────┬────────────────────────┬─────────────────────┐
│ #  │ Client (A)         │ Relay                  │ Client (B)          │
├────┼────────────────────┼────────────────────────┼─────────────────────┤
│ 1  │ JoinRelayRequest-> │                        │                     │
├────┼────────────────────┼────────────────────────┼─────────────────────┤
│ 2  │                    │ <-ResponseSuccess      │                     │
├────┼────────────────────┼────────────────────────┼─────────────────────┤
│ 3  │ Ping->             │                        │                     │
├────┼────────────────────┼────────────────────────┼─────────────────────┤
│ 4  │                    │ <-Pong                 │                     │
├────┼────────────────────┼────────────────────────┼─────────────────────┤
│ 5  │                    │                        │ <-ConnectRequest(A) │
├────┼────────────────────┼────────────────────────┼─────────────────────┤
│ 6  │                    │ SessionInvitation(A)-> │                     │
├────┼────────────────────┼────────────────────────┼─────────────────────┤
│ 7  │                    │ <-SessionInvitation(B) │                     │
├────┼────────────────────┼────────────────────────┼─────────────────────┤
│ 8  │                    │                        │ (Disconnects)       │
├────┼────────────────────┼────────────────────────┼─────────────────────┤
│ 9  │ Ping->             │                        │                     │
├────┼────────────────────┼────────────────────────┼─────────────────────┤
│ 10 │                    │ <-Pong                 │                     │
├────┼────────────────────┼────────────────────────┼─────────────────────┤
│ 11 │ Ping->             │                        │                     │
├────┼────────────────────┼────────────────────────┼─────────────────────┤
│ 12 │                    │ <-Pong                 │                     │
└────┴────────────────────┴────────────────────────┴─────────────────────┘

🌸 SESSION MODE 🌸

Okay so bestie, in session mode, the first and only message the client sends is the JoinSessionRequest message — and it contains the session key that identifies which session you're trying to join 🔑. The relay responds with one of the following messages:

ResponseNotFound — the session key is invalid 💀
ResponseAlreadyConnected — the session is full (both sides already connected) 😭
ResponseSuccess — you have successfully joined the session 🎉
RelayFull — the relay limits are too strict for you to be able to join the session. The relay immediately terminates the connection after sending this ⚠️

After the successful response, all the bytes written and received will be relayed between the two devices in the session directly 🫶.

✨ Example Exchange ✨

Client A is the first to join the session. Client B is the second to join the session. Both are in session mode.

Here's the exchange, step by step:

    ┌───┬─────────────────────────┬───────────────────┬─────────────────────────┐
    │ # │ Client (A)              │ Relay             │ Client (B)              │
    ├───┼─────────────────────────┼───────────────────┼─────────────────────────┤
    │ 1 │ JoinSessionRequest(A)-> │                   │                         │
    ├───┼─────────────────────────┼───────────────────┼─────────────────────────┤
    │ 2 │                         │ <-ResponseSuccess │                         │
    ├───┼─────────────────────────┼───────────────────┼─────────────────────────┤
    │ 3 │ Data->                  │ (Buffers data)    │                         │
    ├───┼─────────────────────────┼───────────────────┼─────────────────────────┤
    │ 4 │ Data->                  │ (Buffers data)    │                         │
    ├───┼─────────────────────────┼───────────────────┼─────────────────────────┤
    │ 5 │                         │                   │ <-JoinSessionRequest(B) │
    ├───┼─────────────────────────┼───────────────────┼─────────────────────────┤
    │ 6 │                         │ ResponseSuccess-> │                         │
    ├───┼─────────────────────────┼───────────────────┼─────────────────────────┤
    │ 7 │                         │ Relays data ->    │                         │
    ├───┼─────────────────────────┼───────────────────┼─────────────────────────┤
    │ 8 │                         │ Relays data ->    │                         │
    ├───┼─────────────────────────┼───────────────────┼─────────────────────────┤
    │ 9 │                         │ <-Relays data     │ <-Data                  │
    └───┴─────────────────────────┴───────────────────┴─────────────────────────┘

💌 MESSAGES 💌

Okay bestie, every single message gets a header first — like a little name tag so you know what's coming. The header contains the magic value 0x9E79BC40, a message type integer, and the message length. Slay.

⚠️ WARNING: Some messages have no content, apart from the implied header which allows us to identify what type of message it is. They're literally just vibes and a type number, no cap.

🎀 Header structure 🎀

           0                   1                   2                   3
           0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          |                             Magic                             |
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          |                         Message Type                          |
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          |                        Message Length                         |
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

          struct Header {
                  unsigned int Magic;
                  int MessageType;
                  int MessageLength;
          }

🏓 Ping message (Type = 0) 🏓

           0                   1                   2                   3
           0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

          struct Ping {
          }

🫶 Pong message (Type = 1) 🫶

           0                   1                   2                   3
           0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

          struct Pong {
          }

🚪 JoinRelayRequest message (Type = 2) 🚪

           0                   1                   2                   3
           0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

          struct JoinRelayRequest {
          }

🔑 JoinSessionRequest message (Type = 3) 🔑

           0                   1                   2                   3
           0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          |                         Length of Key                         |
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          /                                                               /
          \                     Key (variable length)                     \
          /                                                               /
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

          struct JoinSessionRequest {
                  opaque Key<32>;
          }

Key — This is a unique random session key generated by the relay server. It is used to identify which session you are trying to connect to. It's giving "VIP wristband at the relay club" energy, honestly.

📬 Response message (Type = 4) 📬

           0                   1                   2                   3
           0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          |                             Code                              |
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          |                       Length of Message                       |
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          /                                                               /
          \                   Message (variable length)                   \
          /                                                               /
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

          struct Response {
                  int Code;
                  string Message<>;
          }

Code — An integer representing the status code. The relay's little mood ring.
Message — Message associated with the code. The relay's out-loud explanation of that mood.

And here are the exact response glow-ups, no notes:

          ResponseSuccess           = Response{0, "success"}
          ResponseNotFound          = Response{1, "not found"}
          ResponseAlreadyConnected  = Response{2, "already connected"}
          ResponseInternalError     = Response{99, "internal error"}
          ResponseUnexpectedMessage = Response{100, "unexpected message"}

🔌 ConnectRequest message (Type = 5) 🔌

           0                   1                   2                   3
           0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          |                         Length of ID                          |
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          /                                                               /
          \                     ID (variable length)                      \
          /                                                               /
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

          struct ConnectRequest {
                  opaque ID<32>;
          }

ID — Device ID to which the client would like to connect. Like sliding into the right device's DMs, but with cryptography.

💌 SessionInvitation message (Type = 6) 💌

           0                   1                   2                   3
           0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          |                        Length of From                         |
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          /                                                               /
          \                    From (variable length)                     \
          /                                                               /
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          |                         Length of Key                         |
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          /                                                               /
          \                     Key (variable length)                     \
          /                                                               /
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          |                       Length of Address                       |
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          /                                                               /
          \                   Address (variable length)                   \
          /                                                               /
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          |            0x0000             |             Port              |
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
          |                  Server Socket (V=0 or 1)                   |V|
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

          struct SessionInvitation {
                  opaque From<32>;
                  opaque Key<32>;
                  opaque Address<32>;
                  unsigned int Port;
                  bool ServerSocket;
          }

From — Device ID identifying who you will be connecting with. The "you're meeting up with this one" field.
Key — A unique random session key generated by the relay server. It is used to identify which session you are trying to connect to. Same iconic VIP wristband as before.
Address — An optional IP address on which the relay server is expecting you to connect, in order to start a connection in session mode. Empty/all zero IP should be replaced with the relay’s public IP address that was used when establishing the protocol mode connection.
Port — The port on which the relay server is expecting you to connect, in order to start a connection in session mode.
Server Socket — Because both sides connecting to the relay use the client side of the socket, and some protocols behave differently depending if the connection starts on the server side or the client side, this boolean indicates which side of the connection this client should assume it’s getting. The value is inverted in the invitation which is sent to the other device, so that there is always one client socket, and one server socket. It's literally a "you be the server, I'll be the client" handshake, periodt.

💀 RelayFull message (Type = 7) 💀

           0                   1                   2                   3
           0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
          +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

          struct RelayFull {
          }

🛡️ HOW SYNCTHING USES RELAYS, AND GENERAL SECURITY 🛡️

Bestie, here's where it gets genuinely reassuring. In the case of Syncthing and BEP, when two devices connect via relay, they start their standard TLS connection encapsulated within the relay’s plain-text session connection — effectively upgrading the plain-text connection to a TLS connection. It's giving "we met at a public spot but we immediately stepped into a private booth."

Even though the relay could be used for man-in-the-middle attack, using TLS at the application/BEP level ensures that all the traffic is safely encrypted, and is completely meaningless to the relay. Like, the relay is carrying the bags but it has zero clue what's in them. Furthermore, the secure suite of ciphers used by BEP provides forward secrecy, meaning that even if the relay did capture all the traffic, and even if the attacker did get their hands on the device keys, they would still not be able to recover/decrypt any traffic which was transported via the relay. Forward secrecy ate and left no crumbs.

After establishing a relay session, Syncthing looks at the SessionInvitation message, and depending which side it has received, wraps the raw socket in either a TLS client socket or a TLS server socket depending on the ServerSocket boolean value in the SessionInvitation, and starts the TLS handshake. Main character energy from the handshake onward, honestly.

From that point onwards it functions exactly the same way as if Syncthing was establishing a direct connection with the other device over the internet, performing device ID validation, and full TLS encryption, and provides the same security properties as it would provide when connecting over the internet. So yeah — relayed, but still fully encrypted, fully validated, fully safe. 🫶

✨ EXAMPLES OF STRONG CIPHER SUITES ✨

okay bestie, this is the good-stuff list 💅 these are the cipher suites you actually want on ur relay — the strong ones, the ones that make the vibe check pass with flying colors. Each one's got an ID, a Name, and a lil Description of what's going on under the hood. Slay.

0x009F — DHE-RSA-AES256-GCM-SHA384 — TLSv1.2 DH RSA AESGCM(256) AEAD 🫶
0x006B — DHE-RSA-AES256-SHA256 — TLSv1.2 DH RSA AES(256) SHA256
0xC030 — ECDHE-RSA-AES256-GCM-SHA384 — TLSv1.2 ECDH RSA AESGCM(256) AEAD 🔥
0xC028 — ECDHE-RSA-AES256-SHA384 — TLSv1.2 ECDH RSA AES(256) SHA384
0x009E — DHE-RSA-AES128-GCM-SHA256 — TLSv1.2 DH RSA AESGCM(128) AEAD
0x0067 — DHE-RSA-AES128-SHA256 — TLSv1.2 DH RSA AES(128) SHA256
0xC02F — ECDHE-RSA-AES128-GCM-SHA256 — TLSv1.2 ECDH RSA AESGCM(128) AEAD ✨
0xC027 — ECDHE-RSA-AES128-SHA256 — TLSv1.2 ECDH RSA AES(128) SHA256

like, the AEAD girlies at the top? iconic. main character energy fr fr. the ones with bigger numbers aren't automatically better either — it's giving sophistication, not a size contest 😌

👑 AUTHOR 👑

The Syncthing Authors

(they ate and left zero crumbs, no cap 💜)

🎀 COPYRIGHT 🎀

2014-2026, The Syncthing Authors

okay that's literally the whole page, bestie!! 🦋 you made it to the end, i'm so proud of you. go forth and relay responsibly — strong ciphers only, always read the fine print, and remember: the vibe check is eternal. mwah 💋

this lil masterpiece is from source/version v2.1.0, dated Oct 07, 2026 — take a screenshot, frame it, put it on the fridge 🫶✨

📦 where this page comes from

arch rolling: syncthing 2.1.7-1 · MPL-2.0
nixos 26.05: syncthing 2.1.7
nixpkgs unstable: syncthing 2.1.7
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-04: a language model's rewrite of the original, under its terms