---
title: "VLESS"
description: "Les transports, flux, chiffrement, options TLS, liens et fonctionnalités VLESS pris en charge par Potatso."
---

> 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

Un serveur VLESS se décrit par un **ID utilisateur** (un UUID), sa **sécurité** (aucune, TLS ou REALITY) et un **transport** qui porte la connexion, comme WebSocket ou gRPC. Il peut aussi utiliser le **flux Vision**, qui masque le motif « TLS dans TLS » du trafic HTTPS proxifié, et **VLESS Encryption**, la couche de chiffrement post-quantique de Xray. Potatso se connecte à un serveur lorsqu’il prend en charge tous ces réglages. Utilisez les tableaux ci-dessous pour vérifier les réglages de votre serveur, tels que votre fournisseur les indique ou tels qu’ils figurent dans son lien `vless://`.

Vous pouvez ajouter un serveur VLESS à la main, avec un [lien `vless://`](#links), ou en important :

- un abonnement Clash ou Mihomo,
- une configuration Xray ou V2Ray.

Potatso n’importe pas encore les serveurs VLESS d’une configuration sing-box. Utilisez plutôt le lien `vless://` du serveur.

Chaque réglage pris en charge ci-dessous est testé avec de vrais serveurs [Xray](https://github.com/XTLS/Xray-core) et [sing-box](https://sing-box.sagernet.org/).

## ID utilisateur {#user-id}

L’ID utilisateur est normalement un UUID, comme `3971e1b2-18a3-4f83-8fa6-bf9b142ee258`. Les serveurs Xray acceptent aussi comme ID n’importe quel autre texte d’au plus 30 caractères, et le transforment en UUID de la même façon que tous les clients. Potatso aussi : utilisez donc l’ID exactement comme votre fournisseur vous le donne.

## Transports {#transports}

| Transport | `type` du lien | Pris en charge | Testé avec |
| --- | --- | --- | --- |
| Sans transport (TCP brut) | `tcp`, `raw`, ou aucun | ✅ | Xray, sing-box |
| WebSocket | `ws` | ✅ Avec ou sans early data | Xray, sing-box |
| gRPC | `grpc` | ✅ | Xray, sing-box |
| HTTP Upgrade | `httpupgrade` | ✅ | Xray, sing-box |
| [XHTTP](#xhttp) | `xhttp`, `splithttp` | ✅ En mode `stream-one` et `auto` | Xray |
| HTTP/2 | `http` ou `h2` | ✅ | sing-box |
| mKCP | `kcp` | ❌ | |
| QUIC | `quic` | ❌ | |
| TCP avec obfuscation d’en-tête HTTP | `tcp` avec `headerType=http` | ❌ | |

Chaque transport fonctionne avec et sans TLS, et avec l’UDP. Potatso n’importe pas un serveur dont il ne prend pas en charge le transport.

Xray ne propose plus HTTP/2 ni QUIC : les serveurs Xray qui les utilisaient utilisent désormais XHTTP.

### XHTTP {#xhttp}

XHTTP (anciennement SplitHTTP) a plusieurs modes. Potatso envoie toute la connexion comme une seule requête HTTP (`stream-one`). Un serveur Xray l’accepte dans son mode `auto` par défaut ainsi que dans les modes `stream-one` et `stream-up` : un lien avec `mode=auto`, ou sans mode, fonctionne donc.

Potatso ne prend pas en charge les modes client `packet-up` et `stream-up`, et n’importe pas un lien qui les demande. Le paramètre `extra` d’un lien XHTTP n’est pas pris en charge : Potatso l’ignore. Dans l’app, vous ne pouvez modifier les serveurs XHTTP qu’avec TLS ou REALITY ; un serveur XHTTP importé sans TLS fonctionne quand même.

## Sécurité {#security}

| Sécurité | `security` du lien | Pris en charge |
| --- | --- | --- |
| Aucune | `none`, ou aucune | ✅ Votre trafic n’est pas chiffré, sauf si le serveur utilise [VLESS Encryption](#encryption). |
| TLS | `tls` | ✅ |
| [REALITY](#reality) | `reality` | ✅ Sans transport, avec gRPC ou XHTTP |

### Réglages TLS {#tls}

| Réglage | Clé Clash | Paramètre de lien | Pris en charge |
| --- | --- | --- | --- |
| Nom du serveur (SNI) | `servername` | `sni` | ✅ Sans nom, Potatso utilise l’adresse du serveur. |
| ALPN | `alpn` | `alpn` | ✅ Sans ALPN, Potatso envoie `http/1.1` pour WebSocket, `h2` pour gRPC, HTTP/2 et XHTTP, et rien pour les autres. |
| Ignorer la vérification du certificat | `skip-cert-verify` | `allowInsecure`, `insecure` | ✅ |
| Épinglage de certificat (SHA-256) | `fingerprint` | `pcs` | ✅ Un certificat |
| Vérifier le certificat par rapport à un autre nom | | `vcn` | ❌ Potatso vérifie le certificat par rapport au nom du serveur. |
| Empreinte de navigateur | `client-fingerprint` | `fp` | ✅ `chrome`, `firefox`, `safari`, `ios`, `android`, `edge` et `random`. Les autres noms se connectent avec une négociation par défaut. |
| Encrypted Client Hello (ECH) | `ech-opts` | `ech` | ✅ Avec la configuration ECH du lien ou de l’abonnement |
| Certificat CA personnalisé | | | ❌ |
| Certificat client TLS | `certificate`, `private-key` | | ❌ |

Désactiver la vérification du certificat permet à n’importe qui entre vous et le serveur de lire votre trafic. Épinglez plutôt le certificat du serveur s’il est autosigné : saisissez le SHA-256 de son certificat comme épinglage de certificat. Potatso épingle un seul certificat ; il n’importe pas un lien qui en liste plusieurs dans `pcs`.

Une empreinte de navigateur fait ressembler la négociation TLS de la connexion à celle de ce navigateur. Elle ne change pas ce que le serveur doit prendre en charge.

### REALITY {#reality}

Un serveur REALITY emprunte le certificat TLS d’un autre site web, il n’a donc pas besoin du sien. Saisissez la **clé publique** et l'**ID court** du serveur tels que votre fournisseur les indique, et le nom du serveur du site web auquel le serveur emprunte. Le `spx` du lien (spider path) n’est pas nécessaire pour se connecter, et Potatso l’ignore.

REALITY exige une empreinte de navigateur : quand votre lien ou vos réglages n’en ont pas, Potatso utilise `chrome`. Avec REALITY, `android` et les noms que Potatso ne connaît pas se connectent aussi comme `chrome`.

REALITY fonctionne sans transport, avec gRPC et avec XHTTP.

## Flux Vision {#vision}

| Flux | `flow` du lien | Pris en charge |
| --- | --- | --- |
| Aucun | aucun | ✅ |
| Vision | `xtls-rprx-vision` | ✅ |
| Vision, UDP 443 autorisé | `xtls-rprx-vision-udp443` | ✅ |
| `xtls-rprx-direct`, `xtls-rprx-splice` et les autres anciens flux XTLS | | ❌ Xray les a supprimés |

Vision ne fonctionne qu’avec TLS ou REALITY et sans transport : Potatso n’enregistre ni n’importe un serveur Vision avec un autre transport ou sans TLS. Il fonctionne aussi avec VLESS Encryption par-dessus TLS.

Avec Vision, l’UDP est transporté comme Xray le transporte, via Mux.Cool, que les serveurs Xray et sing-box acceptent tous deux. Le client Xray refuse l’UDP vers le port 443 (QUIC) avec `xtls-rprx-vision`, pour que les navigateurs se replient sur le TCP ; Potatso le transporte avec les deux flux.

## VLESS Encryption {#encryption}

VLESS Encryption (`mlkem768x25519plus`) est la couche de chiffrement post-quantique de Xray : un échange de clés ML-KEM-768 et X25519 sous la connexion VLESS. Le réglage `decryption` du serveur a une valeur `encryption` correspondante pour les clients, qui ressemble à ceci :

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

| Réglage | Pris en charge |
| --- | --- |
| Modes `native`, `xorpub` et `random` | ✅ |
| `1rtt` et `0rtt` (connexions reprises) | ✅ |
| Serveur authentifié avec une clé X25519 ou ML-KEM-768 | ✅ |
| Sans transport et sans TLS | ✅ |
| Par-dessus TLS | ✅ Aussi avec Vision |
| Vision sans TLS | ❌ |

Potatso conserve la valeur `encryption` d’un lien, d’un abonnement Clash ou d’une configuration Xray. Vous ne pouvez pas encore en saisir une dans les réglages du serveur.

## Multiplexage {#mux}

Potatso peut faire passer plusieurs connexions par une seule connexion VLESS, défini avec `smux` dans un abonnement Clash :

| Protocole | `smux.protocol` Clash | Serveurs | Pris en charge |
| --- | --- | --- | --- |
| Mux.Cool (Xray) | `muxcool` | Xray, sing-box | ✅ TCP et UDP |
| Multiplexage sing-box | `smux`, `yamux`, `h2mux` | sing-box, avec le multiplexage activé | ✅ TCP et UDP, avec ou sans bourrage |

Avec Vision, Mux.Cool ne transporte que l’UDP et chaque connexion TCP garde sa propre connexion, comme dans Xray. Le multiplexage sing-box ne fonctionne pas avec Vision, et Potatso n’importe pas un serveur Vision qui le demande.

Les réglages `mux` de Xray dans une configuration Xray ne sont pas importés.

## UDP {#udp}

VLESS transporte l’UDP sur la même connexion que le TCP. L’UDP est désactivé par défaut, comme dans Clash. Activez Relais UDP dans les réglages du serveur si votre serveur relaie l’UDP : Xray et sing-box le font tous deux. Un abonnement Clash l’active avec `udp: true`.

Chaque flux UDP obtient sa propre connexion vers le serveur, et chaque destination son propre flux. Potatso ne prend pas en charge XUDP ni packetaddr (`packetEncoding` dans un lien, `packet-encoding` ou `xudp` dans un abonnement) : les serveurs acceptent l’UDP de Potatso sans eux, et Potatso ignore le réglage.

## Fonctionnalités prises en charge {#features}

| Fonctionnalité | Pris en charge |
| --- | --- |
| [Protocole VLESS](https://xtls.github.io/en/development/protocols/vless.html) version 0 : commandes TCP et UDP | ✅ |
| UUID et ID utilisateur textuels | ✅ |
| Plusieurs utilisateurs sur un serveur | ✅ Chacun avec son propre ID |
| Flux Vision (`xtls-rprx-vision`, `-udp443`) | ✅ Voir [Vision](#vision) |
| VLESS Encryption (`mlkem768x25519plus`) | ✅ Voir [VLESS Encryption](#encryption) |
| TLS, REALITY, ECH, épinglage de certificat, empreintes de navigateur | ✅ Voir [Sécurité](#security) |
| Transports WebSocket, gRPC, HTTP Upgrade, HTTP/2 | ✅ Voir [Transports](#transports) |
| XHTTP | Modes `stream-one` et `auto` |
| mKCP, QUIC, obfuscation d’en-tête HTTP en TCP | ❌ |
| Mux.Cool | ✅ |
| XUDP, packetaddr | ❌ L’UDP utilise la commande UDP simple |
| Multiplexage sing-box (smux, yamux, h2mux) | ✅ |
| Proxy inverse (`reverse` de VLESS) | ❌ C’est une fonctionnalité serveur |
| Liens `vless://` ([standard de lien de partage Xray](https://github.com/XTLS/Xray-core/discussions/716)) | ✅ |

## Liens `vless://` {#links}

Un lien `vless://` contient un serveur entier sur une ligne :

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

| Partie | Description |
| --- | --- |
| `id` | L’ID utilisateur. |
| `host` | Adresse du serveur. Placez une adresse IPv6 entre crochets, comme `[2001:db8::1]`. |
| `port` | Port du serveur. |
| `encryption` | `none`, ou une valeur [VLESS Encryption](#encryption). |
| `flow` | Facultatif. `xtls-rprx-vision` ou `xtls-rprx-vision-udp443`. |
| `type` | Le [transport](#transports). |
| `security` | `none`, `tls` ou `reality`. |
| `sni`, `alpn`, `fp`, `pcs`, `ech`, `allowInsecure` | [Réglages TLS](#tls). |
| `pbk`, `sid` | La clé publique et l’ID court REALITY. |
| `host`, `path` | L’en-tête `Host` et le chemin de WebSocket, HTTP Upgrade, HTTP/2 et XHTTP. Un chemin WebSocket peut transporter de l’early data sous la forme `?ed=2048`. |
| `serviceName` | Le nom du service gRPC. |
| `mode` | Le mode XHTTP. |
| `name` | Facultatif. Le nom du serveur dans Potatso. |

Quand Potatso partage un serveur VLESS, il écrit un lien sous cette forme.

### Exemples {#link-examples}

Chaque exemple montre le lien à importer. L’ID utilisateur est `3971e1b2-18a3-4f83-8fa6-bf9b142ee258`.

TLS sans transport :

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

REALITY avec Vision, en empruntant `www.example.com` :

```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 sur TLS via un CDN, avec 2048 octets d’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 sur TLS :

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

HTTP Upgrade sur TLS :

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

XHTTP sur 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 sur 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 sans 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/fr/protocols/vless/index.mdx