---
title: "VLESS"
description: "Die von Potatso unterstützten VLESS-Transporte, Flows, Verschlüsselung, TLS-Optionen, Links und Funktionen."
---

> Documentation Index
> Fetch the complete documentation index at: https://potatso.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# VLESS

Ein VLESS-Server wird durch eine **Benutzer-ID** (eine UUID), seine **Sicherheit** (keine, TLS oder REALITY) und einen **Transport** beschrieben, der die Verbindung trägt, etwa WebSocket oder gRPC. Er kann außerdem den **Vision-Datenfluss** nutzen, der das Muster „TLS in TLS“ von über Proxy geleitetem HTTPS-Datenverkehr verbirgt, sowie **VLESS Encryption**, die Post-Quanten-Verschlüsselungsschicht von Xray. Potatso verbindet sich mit einem Server, wenn es all diese Einstellungen unterstützt. Prüfe anhand der Tabellen unten die Einstellungen deines Servers, wie dein Anbieter sie angibt oder wie sie in seinem `vless://`-Link stehen.

Einen VLESS-Server kannst du von Hand, mit einem [`vless://`-Link](#links) oder per Import hinzufügen:

- eines Clash- oder Mihomo-Abonnements,
- einer Xray- oder V2Ray-Konfiguration.

Potatso importiert VLESS-Server noch nicht aus einer sing-box-Konfiguration. Nutze stattdessen den `vless://`-Link des Servers.

Jede unten genannte unterstützte Einstellung ist gegen echte [Xray](https://github.com/XTLS/Xray-core)- und [sing-box](https://sing-box.sagernet.org/)-Server getestet.

## Benutzer-ID {#user-id}

Die Benutzer-ID ist normalerweise eine UUID, etwa `3971e1b2-18a3-4f83-8fa6-bf9b142ee258`. Xray-Server akzeptieren als ID auch jeden anderen Text mit bis zu 30 Zeichen und machen daraus auf dieselbe Weise eine UUID wie jeder Client. Potatso tut das ebenfalls, verwende die ID also genau so, wie dein Anbieter sie angibt.

## Transporte {#transports}

| Transport | Link-`type` | Unterstützt | Getestet mit |
| --- | --- | --- | --- |
| Kein Transport (rohes TCP) | `tcp`, `raw` oder keiner | ✅ | Xray, sing-box |
| WebSocket | `ws` | ✅ Mit oder ohne Early Data | Xray, sing-box |
| gRPC | `grpc` | ✅ | Xray, sing-box |
| HTTP Upgrade | `httpupgrade` | ✅ | Xray, sing-box |
| [XHTTP](#xhttp) | `xhttp`, `splithttp` | ✅ Im Modus `stream-one` und `auto` | Xray |
| HTTP/2 | `http` oder `h2` | ✅ | sing-box |
| mKCP | `kcp` | ❌ | |
| QUIC | `quic` | ❌ | |
| TCP mit HTTP-Header-Verschleierung | `tcp` mit `headerType=http` | ❌ | |

Jeder Transport funktioniert mit und ohne TLS und mit UDP. Potatso importiert keinen Server, dessen Transport es nicht unterstützt.

Xray bietet HTTP/2 und QUIC nicht mehr an: Xray-Server, die sie nutzten, verwenden jetzt XHTTP.

### XHTTP {#xhttp}

XHTTP (früher SplitHTTP) hat mehrere Modi. Potatso sendet die gesamte Verbindung als eine HTTP-Anfrage (`stream-one`). Ein Xray-Server akzeptiert das im Standardmodus `auto` sowie in den Modi `stream-one` und `stream-up`, ein Link mit `mode=auto` oder ohne Modus funktioniert also.

Potatso unterstützt die Client-Modi `packet-up` und `stream-up` nicht und importiert keinen Link, der sie verlangt. Der Parameter `extra` eines XHTTP-Links wird nicht unterstützt: Potatso ignoriert ihn. Potatso bearbeitet XHTTP-Server mit TLS oder REALITY; ein importierter XHTTP-Server ohne TLS funktioniert trotzdem.

## Sicherheit {#security}

| Sicherheit | Link-`security` | Unterstützt |
| --- | --- | --- |
| Keine | `none` oder keine | ✅ Dein Datenverkehr ist nicht verschlüsselt, außer der Server nutzt [VLESS Encryption](#encryption). |
| TLS | `tls` | ✅ |
| [REALITY](#reality) | `reality` | ✅ Ohne Transport, mit gRPC oder XHTTP |

### TLS-Einstellungen {#tls}

| Einstellung | Clash-Schlüssel | Link-Parameter | Unterstützt |
| --- | --- | --- | --- |
| Servername (SNI) | `servername` | `sni` | ✅ Ohne Angabe verwendet Potatso die Adresse des Servers. |
| ALPN | `alpn` | `alpn` | ✅ Ohne Angabe sendet Potatso `http/1.1` für WebSocket, `h2` für gRPC, HTTP/2 und XHTTP und bei den übrigen nichts. |
| Zertifikatsprüfung überspringen | `skip-cert-verify` | `allowInsecure`, `insecure` | ✅ |
| Zertifikat-Pinning (SHA-256) | `fingerprint` | `pcs` | ✅ Ein Zertifikat |
| Das Zertifikat für einen anderen Namen prüfen | | `vcn` | ❌ Potatso prüft das Zertifikat gegen den Servernamen. |
| Browser-Fingerabdruck | `client-fingerprint` | `fp` | ✅ `chrome`, `firefox`, `safari`, `ios`, `android`, `edge` und `random`. Andere Namen verbinden mit einem Standard-Handshake. |
| Encrypted Client Hello (ECH) | `ech-opts` | `ech` | ✅ Mit der ECH-Konfiguration im Link oder Abonnement |
| Eigenes CA-Zertifikat | | | ❌ |
| TLS-Clientzertifikat | `certificate`, `private-key` | | ❌ |

Schaltest du die Zertifikatsprüfung aus, kann jeder zwischen dir und dem Server deinen Datenverkehr mitlesen. Pinne stattdessen das Zertifikat des Servers, wenn er ein selbstsigniertes nutzt: Setze den SHA-256 seines Zertifikats als Zertifikat-Pin. Potatso pinnt ein Zertifikat; es importiert keinen Link, der mehrere in `pcs` auflistet.

Ein Browser-Fingerabdruck lässt den TLS-Handshake der Verbindung wie den dieses Browsers aussehen. Er ändert nicht, was der Server unterstützen muss.

### REALITY {#reality}

Ein REALITY-Server leiht sich das TLS-Zertifikat einer anderen Website und braucht daher kein eigenes. Setze den **Reality-Public-Key** und die **Reality-Short-ID** des Servers so, wie dein Anbieter sie angibt, und den Servernamen auf die Website, bei der sich der Server bedient. Das `spx` (Spider-Pfad) des Links wird zum Verbinden nicht gebraucht, und Potatso ignoriert es.

REALITY braucht einen Browser-Fingerabdruck: Haben dein Link oder deine Einstellungen keinen, verwendet Potatso `chrome`. Bei REALITY verbinden auch `android` und Namen, die Potatso nicht kennt, als `chrome`.

REALITY funktioniert ohne Transport, mit gRPC und mit XHTTP.

## Vision-Datenfluss {#vision}

| Datenfluss | Link-`flow` | Unterstützt |
| --- | --- | --- |
| Keiner | keiner | ✅ |
| Vision | `xtls-rprx-vision` | ✅ |
| Vision, UDP 443 erlaubt | `xtls-rprx-vision-udp443` | ✅ |
| `xtls-rprx-direct`, `xtls-rprx-splice` und andere alte XTLS-Flows | | ❌ Von Xray entfernt |

Vision funktioniert nur ohne Transport und mit TLS oder REALITY: Potatso speichert oder importiert keinen Vision-Server mit einem anderen Transport oder ohne TLS. Es funktioniert auch mit VLESS Encryption über TLS.

Mit Vision wird UDP so getragen, wie Xray es trägt, über Mux.Cool, das Xray- wie sing-box-Server akzeptieren. Der eigene Client von Xray lehnt UDP zu Port 443 (QUIC) mit `xtls-rprx-vision` ab, damit Browser auf TCP zurückfallen; Potatso trägt es mit beiden Flows.

## VLESS Encryption {#encryption}

VLESS Encryption (`mlkem768x25519plus`) ist die Post-Quanten-Verschlüsselungsschicht von Xray: ein Schlüsselaustausch mit ML-KEM-768 und X25519 unter der VLESS-Verbindung. Die Einstellung `decryption` des Servers hat einen passenden `encryption`-Wert für Clients, der so aussieht:

```text
mlkem768x25519plus.native.0rtt.<key>
```

| Einstellung | Unterstützt |
| --- | --- |
| Modi `native`, `xorpub` und `random` | ✅ |
| `1rtt` und `0rtt` (fortgesetzte Verbindungen) | ✅ |
| Server, der mit einem X25519- oder einem ML-KEM-768-Schlüssel authentifiziert ist | ✅ |
| Ohne Transport und ohne TLS | ✅ |
| Über TLS | ✅ Auch mit Vision |
| Vision ohne TLS | ❌ |

Potatso behält den `encryption`-Wert eines Links, Clash-Abonnements oder einer Xray-Konfiguration bei. In den Servereinstellungen kannst du noch keinen eingeben.

## Multiplexing {#mux}

Potatso kann mehrere Verbindungen über eine VLESS-Verbindung führen, in einem Clash-Abonnement über `smux` festgelegt:

| Protokoll | Clash-`smux.protocol` | Server | Unterstützt |
| --- | --- | --- | --- |
| Mux.Cool (Xray) | `muxcool` | Xray, sing-box | ✅ TCP und UDP |
| Multiplexing von sing-box | `smux`, `yamux`, `h2mux` | sing-box, mit eingeschaltetem Multiplexing | ✅ TCP und UDP, mit oder ohne Padding |

Mit Vision trägt Mux.Cool nur UDP, und jede TCP-Verbindung behält ihre eigene Verbindung, wie in Xray. Das Multiplexing von sing-box funktioniert nicht mit Vision, und Potatso importiert keinen Vision-Server, der es verlangt.

Die `mux`-Einstellungen von Xray in einer Xray-Konfiguration werden nicht importiert.

## UDP {#udp}

VLESS trägt UDP über dieselbe Verbindung wie TCP. UDP ist wie in Clash standardmäßig aus. Schalte UDP-Relay in den Servereinstellungen ein, wenn dein Server UDP weiterleitet: Xray und sing-box tun das beide. Ein Clash-Abonnement schaltet es mit `udp: true` ein.

Jeder UDP-Flow erhält eine eigene Verbindung zum Server und jedes Ziel einen eigenen Flow. Potatso unterstützt weder XUDP noch packetaddr (`packetEncoding` in einem Link, `packet-encoding` oder `xudp` in einem Abonnement): Server akzeptieren das UDP von Potatso auch ohne sie, und Potatso ignoriert die Einstellung.

## Funktionsunterstützung {#features}

| Funktion | Unterstützt |
| --- | --- |
| [VLESS-Protokoll](https://xtls.github.io/en/development/protocols/vless.html) Version 0: TCP- und UDP-Befehle | ✅ |
| UUIDs und Text als Benutzer-ID | ✅ |
| Mehrere Benutzer auf einem Server | ✅ Jeder mit eigener ID |
| Vision-Datenfluss (`xtls-rprx-vision`, `-udp443`) | ✅ Siehe [Vision](#vision) |
| VLESS Encryption (`mlkem768x25519plus`) | ✅ Siehe [VLESS Encryption](#encryption) |
| TLS, REALITY, ECH, Zertifikat-Pinning, Browser-Fingerabdrücke | ✅ Siehe [Sicherheit](#security) |
| Transporte WebSocket, gRPC, HTTP Upgrade, HTTP/2 | ✅ Siehe [Transporte](#transports) |
| XHTTP | Modus `stream-one` und `auto` |
| mKCP, QUIC, TCP-HTTP-Header-Verschleierung | ❌ |
| Mux.Cool | ✅ |
| XUDP, packetaddr | ❌ UDP nutzt den einfachen UDP-Befehl |
| Multiplexing von sing-box (smux, yamux, h2mux) | ✅ |
| Reverse-Proxy (VLESS `reverse`) | ❌ Das ist eine Serverfunktion |
| `vless://`-Links ([Xray-Share-Link-Standard](https://github.com/XTLS/Xray-core/discussions/716)) | ✅ |

## `vless://`-Links {#links}

Ein `vless://`-Link enthält einen ganzen Server in einer Zeile:

```text
vless://id@host:port?type=…&security=…&…#name
```

| Teil | Beschreibung |
| --- | --- |
| `id` | Die Benutzer-ID. |
| `host` | Serveradresse. Setze eine IPv6-Adresse in eckige Klammern, etwa `[2001:db8::1]`. |
| `port` | Serverport. |
| `encryption` | `none` oder ein Wert für [VLESS Encryption](#encryption). |
| `flow` | Optional. `xtls-rprx-vision` oder `xtls-rprx-vision-udp443`. |
| `type` | Der [Transport](#transports). |
| `security` | `none`, `tls` oder `reality`. |
| `sni`, `alpn`, `fp`, `pcs`, `ech`, `allowInsecure` | [TLS-Einstellungen](#tls). |
| `pbk`, `sid` | Der REALITY-Public-Key und die Short-ID. |
| `host`, `path` | Der `Host`-Header und der Pfad von WebSocket, HTTP Upgrade, HTTP/2 und XHTTP. Ein WebSocket-Pfad kann Early Data als `?ed=2048` tragen. |
| `serviceName` | Der gRPC-Dienstname. |
| `mode` | Der XHTTP-Modus. |
| `name` | Optional. Der Name des Servers in Potatso. |

Wenn Potatso einen VLESS-Server teilt, schreibt es einen Link in dieser Form.

### Beispiele {#link-examples}

Jedes Beispiel zeigt den Link zum Importieren. Die Benutzer-ID ist `3971e1b2-18a3-4f83-8fa6-bf9b142ee258`.

TLS ohne Transport:

```text
vless://3971e1b2-18a3-4f83-8fa6-bf9b142ee258@vless.example.com:443?security=tls&sni=vless.example.com&type=tcp#TLS
```

REALITY mit Vision, bei `www.example.com` bedient:

```text
vless://3971e1b2-18a3-4f83-8fa6-bf9b142ee258@vless.example.com:443?security=reality&sni=www.example.com&fp=chrome&pbk=Z84J2IelR9ch3k8VtlVhhs5ycBUlXA7wHBWcBrjqnAw&sid=0123abcd&type=tcp&flow=xtls-rprx-vision#REALITY-Vision
```

WebSocket über TLS durch ein CDN, mit 2048 Byte Early Data:

```text
vless://3971e1b2-18a3-4f83-8fa6-bf9b142ee258@vless.example.com:443?security=tls&type=ws&host=cdn.example.com&path=%2Fws%3Fed%3D2048#WebSocket
```

gRPC über TLS:

```text
vless://3971e1b2-18a3-4f83-8fa6-bf9b142ee258@vless.example.com:443?security=tls&type=grpc&serviceName=gun#gRPC
```

HTTP Upgrade über TLS:

```text
vless://3971e1b2-18a3-4f83-8fa6-bf9b142ee258@vless.example.com:443?security=tls&type=httpupgrade&host=cdn.example.com&path=%2Fup#HTTPUpgrade
```

XHTTP über TLS:

```text
vless://3971e1b2-18a3-4f83-8fa6-bf9b142ee258@vless.example.com:443?security=tls&type=xhttp&host=cdn.example.com&path=%2Fxh&mode=auto#XHTTP
```

HTTP/2 über TLS:

```text
vless://3971e1b2-18a3-4f83-8fa6-bf9b142ee258@vless.example.com:443?security=tls&type=http&host=cdn.example.com&path=%2Fh2#HTTP2
```

VLESS Encryption ohne TLS:

```text
vless://3971e1b2-18a3-4f83-8fa6-bf9b142ee258@vless.example.com:8443?security=none&encryption=mlkem768x25519plus.native.0rtt.u7dtLE6KgE4mjeBK3oYdNMw6MJB47Ijr_9AG2avwSmY&type=tcp#Encryption
```

Source: https://potatso.com/docs/de/protocols/vless/index.mdx