---
title: "VLESS"
description: "Os transportes, fluxos, criptografia, opções de TLS, links e recursos do VLESS que o Potatso suporta."
---

> 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

Um servidor VLESS é descrito por um **ID de usuário** (um UUID), sua **segurança** (nenhuma, TLS ou REALITY) e um **transporte** que carrega a conexão, como WebSocket ou gRPC. Ele também pode usar o **fluxo Vision**, que esconde o padrão "TLS dentro de TLS" do tráfego HTTPS passando por proxy, e a **VLESS Encryption**, a camada de criptografia pós-quântica do Xray. O Potatso conecta a um servidor quando suporta todos esses ajustes. Use as tabelas abaixo para conferir os ajustes do seu servidor, como mostrados pelo seu provedor ou no link `vless://` dele.

Você pode adicionar um servidor VLESS à mão, com um [link `vless://`](#links), ou importando:

- uma assinatura Clash ou Mihomo,
- uma configuração do Xray ou do V2Ray.

O Potatso ainda não importa servidores VLESS de uma configuração do sing-box. Use o link `vless://` do servidor.

Todo ajuste suportado abaixo é testado com servidores reais [Xray](https://github.com/XTLS/Xray-core) e [sing-box](https://sing-box.sagernet.org/).

## ID de usuário {#user-id}

O ID de usuário normalmente é um UUID, como `3971e1b2-18a3-4f83-8fa6-bf9b142ee258`. Os servidores Xray também aceitam como ID qualquer outro texto de até 30 caracteres e o transformam em um UUID da mesma forma que todos os clientes. O Potatso também faz isso, então use o ID exatamente como o seu provedor o dá.

## Transportes {#transports}

| Transporte | `type` do link | Suportado | Testado com |
| --- | --- | --- | --- |
| Sem transporte (TCP puro) | `tcp`, `raw`, ou nenhum | ✅ | Xray, sing-box |
| WebSocket | `ws` | ✅ Com ou sem early data | Xray, sing-box |
| gRPC | `grpc` | ✅ | Xray, sing-box |
| HTTP Upgrade | `httpupgrade` | ✅ | Xray, sing-box |
| [XHTTP](#xhttp) | `xhttp`, `splithttp` | ✅ No modo `stream-one` e `auto` | Xray |
| HTTP/2 | `http` ou `h2` | ✅ | sing-box |
| mKCP | `kcp` | ❌ | |
| QUIC | `quic` | ❌ | |
| TCP com ofuscação de cabeçalho HTTP | `tcp` com `headerType=http` | ❌ | |

Todos os transportes funcionam com e sem TLS, e com UDP. O Potatso não importa um servidor cujo transporte ele não suporta.

O Xray não oferece mais HTTP/2 nem QUIC: os servidores Xray que os usavam agora usam XHTTP.

### XHTTP {#xhttp}

O XHTTP (antes SplitHTTP) tem vários modos. O Potatso envia a conexão inteira como uma única requisição HTTP (`stream-one`). Um servidor Xray aceita isso no modo padrão `auto` e nos modos `stream-one` e `stream-up`, então um link com `mode=auto`, ou sem modo, funciona.

O Potatso não suporta os modos de cliente `packet-up` e `stream-up` e não importa um link que os peça. O parâmetro `extra` de um link XHTTP não é suportado: o Potatso o ignora. O Potatso edita servidores XHTTP com TLS ou REALITY; um servidor XHTTP importado sem TLS ainda funciona.

## Segurança {#security}

| Segurança | `security` do link | Suportada |
| --- | --- | --- |
| Nenhuma | `none`, ou nenhum | ✅ Seu tráfego não é criptografado, a menos que o servidor use a [VLESS Encryption](#encryption). |
| TLS | `tls` | ✅ |
| [REALITY](#reality) | `reality` | ✅ Sem transporte, gRPC ou XHTTP |

### Ajustes de TLS {#tls}

| Ajuste | Chave do Clash | Parâmetro do link | Suportado |
| --- | --- | --- | --- |
| Nome do servidor (SNI) | `servername` | `sni` | ✅ Sem um, o Potatso usa o endereço do servidor. |
| ALPN | `alpn` | `alpn` | ✅ Sem um, o Potatso envia `http/1.1` para WebSocket, `h2` para gRPC, HTTP/2 e XHTTP, e nada para os outros. |
| Ignorar a verificação de certificado | `skip-cert-verify` | `allowInsecure`, `insecure` | ✅ |
| Fixação de certificado (SHA-256) | `fingerprint` | `pcs` | ✅ Um certificado |
| Verificar o certificado para outro nome | | `vcn` | ❌ O Potatso verifica o certificado com o nome do servidor. |
| Impressão digital do navegador | `client-fingerprint` | `fp` | ✅ `chrome`, `firefox`, `safari`, `ios`, `android`, `edge` e `random`. Outros nomes conectam com um handshake padrão. |
| Encrypted Client Hello (ECH) | `ech-opts` | `ech` | ✅ Com a configuração ECH no link ou na assinatura |
| Certificado CA personalizado | | | ❌ |
| Certificado de cliente TLS | `certificate`, `private-key` | | ❌ |

Desativar a verificação de certificado permite que qualquer pessoa entre você e o servidor leia o seu tráfego. Fixe o certificado do servidor em vez disso, se ele usa um autoassinado: defina o SHA-256 do certificado como a fixação de certificado. O Potatso fixa um certificado; ele não importa um link que lista vários em `pcs`.

Uma impressão digital de navegador faz o handshake TLS da conexão parecer o daquele navegador. Ela não muda o que o servidor precisa suportar.

### REALITY {#reality}

Um servidor REALITY toma emprestado o certificado TLS de outro site, então não precisa de um próprio. Defina a **chave pública** e o **short ID** do servidor como o seu provedor os fornece, e o nome do servidor como o site do qual o servidor toma emprestado. O `spx` (spider path) do link não é necessário para conectar, e o Potatso o ignora.

O REALITY precisa de uma impressão digital de navegador: quando o seu link ou os ajustes não têm uma, o Potatso usa `chrome`. Com o REALITY, `android` e nomes que o Potatso não conhece também conectam como `chrome`.

O REALITY funciona sem transporte, com gRPC e com XHTTP.

## Fluxo Vision {#vision}

| Fluxo | `flow` do link | Suportado |
| --- | --- | --- |
| Nenhum | nenhum | ✅ |
| Vision | `xtls-rprx-vision` | ✅ |
| Vision, UDP 443 permitido | `xtls-rprx-vision-udp443` | ✅ |
| `xtls-rprx-direct`, `xtls-rprx-splice` e outros fluxos XTLS antigos | | ❌ O Xray os removeu |

O Vision só funciona sem transporte e com TLS ou REALITY: o Potatso não salva nem importa um servidor Vision com outro transporte ou sem TLS. Ele também funciona com a VLESS Encryption sobre o TLS.

Com o Vision, o UDP é transportado como o Xray o transporta, sobre Mux.Cool, que servidores Xray e sing-box aceitam. O cliente do próprio Xray recusa UDP para a porta 443 (QUIC) com `xtls-rprx-vision`, para que os navegadores recorram ao TCP; o Potatso o transporta com os dois fluxos.

## VLESS Encryption {#encryption}

A VLESS Encryption (`mlkem768x25519plus`) é a camada de criptografia pós-quântica do Xray: uma troca de chaves ML-KEM-768 e X25519 sob a conexão VLESS. O ajuste `decryption` do servidor tem um valor `encryption` correspondente para os clientes, que se parece com isto:

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

| Ajuste | Suportado |
| --- | --- |
| Modos `native`, `xorpub` e `random` | ✅ |
| `1rtt` e `0rtt` (conexões retomadas) | ✅ |
| Servidor autenticado com uma chave X25519 ou ML-KEM-768 | ✅ |
| Sem transporte e sem TLS | ✅ |
| Sobre o TLS | ✅ Também com o Vision |
| Vision sem TLS | ❌ |

O Potatso mantém o valor `encryption` de um link, de uma assinatura Clash ou de uma configuração do Xray. Você ainda não pode digitar um nos ajustes do servidor.

## Multiplexação {#mux}

O Potatso pode executar várias conexões sobre uma única conexão VLESS, definida com `smux` em uma assinatura Clash:

| Protocolo | `smux.protocol` do Clash | Servidores | Suportado |
| --- | --- | --- | --- |
| Mux.Cool (Xray) | `muxcool` | Xray, sing-box | ✅ TCP e UDP |
| Multiplexação do sing-box | `smux`, `yamux`, `h2mux` | sing-box, com a multiplexação ativada | ✅ TCP e UDP, com ou sem padding |

Com o Vision, o Mux.Cool transporta apenas UDP e cada conexão TCP mantém a própria conexão, como no Xray. A multiplexação do sing-box não funciona com o Vision, e o Potatso não importa um servidor Vision que a peça.

Os ajustes `mux` do Xray em uma configuração do Xray não são importados.

## UDP {#udp}

O VLESS transporta UDP pela mesma conexão do TCP. O UDP vem desativado por padrão, como no Clash. Ative o Relay UDP nos ajustes do servidor se o seu servidor repassa UDP: Xray e sing-box repassam. Uma assinatura Clash o ativa com `udp: true`.

Cada fluxo UDP recebe a própria conexão com o servidor, e cada destino o próprio fluxo. O Potatso não suporta XUDP nem packetaddr (`packetEncoding` em um link, `packet-encoding` ou `xudp` em uma assinatura): os servidores aceitam o UDP do Potatso sem eles, e o Potatso ignora o ajuste.

## Suporte a recursos {#features}

| Recurso | Suportado |
| --- | --- |
| [Protocolo VLESS](https://xtls.github.io/en/development/protocols/vless.html) versão 0: comandos TCP e UDP | ✅ |
| IDs de usuário UUID e de texto | ✅ |
| Vários usuários em um servidor | ✅ Cada um com o próprio ID |
| Fluxo Vision (`xtls-rprx-vision`, `-udp443`) | ✅ Veja [Vision](#vision) |
| VLESS Encryption (`mlkem768x25519plus`) | ✅ Veja [VLESS Encryption](#encryption) |
| TLS, REALITY, ECH, fixação de certificado, impressões digitais de navegador | ✅ Veja [Segurança](#security) |
| Transportes WebSocket, gRPC, HTTP Upgrade, HTTP/2 | ✅ Veja [Transportes](#transports) |
| XHTTP | Modo `stream-one` e `auto` |
| mKCP, QUIC, ofuscação de cabeçalho HTTP no TCP | ❌ |
| Mux.Cool | ✅ |
| XUDP, packetaddr | ❌ O UDP usa o comando UDP simples |
| Multiplexação do sing-box (smux, yamux, h2mux) | ✅ |
| Proxy reverso (`reverse` do VLESS) | ❌ É um recurso do servidor |
| Links `vless://` ([padrão de links de compartilhamento do Xray](https://github.com/XTLS/Xray-core/discussions/716)) | ✅ |

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

Um link `vless://` guarda um servidor inteiro em uma linha:

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

| Parte | Descrição |
| --- | --- |
| `id` | O ID de usuário. |
| `host` | Endereço do servidor. Coloque um endereço IPv6 entre colchetes, como `[2001:db8::1]`. |
| `port` | Porta do servidor. |
| `encryption` | `none`, ou um valor da [VLESS Encryption](#encryption). |
| `flow` | Opcional. `xtls-rprx-vision` ou `xtls-rprx-vision-udp443`. |
| `type` | O [transporte](#transports). |
| `security` | `none`, `tls` ou `reality`. |
| `sni`, `alpn`, `fp`, `pcs`, `ech`, `allowInsecure` | [Ajustes de TLS](#tls). |
| `pbk`, `sid` | A chave pública e o short ID do REALITY. |
| `host`, `path` | O cabeçalho `Host` e o caminho de WebSocket, HTTP Upgrade, HTTP/2 e XHTTP. Um caminho WebSocket pode levar early data como `?ed=2048`. |
| `serviceName` | O nome do serviço gRPC. |
| `mode` | O modo XHTTP. |
| `name` | Opcional. O nome do servidor no Potatso. |

Ao compartilhar um servidor VLESS, o Potatso escreve um link nesta forma.

### Exemplos {#link-examples}

Cada exemplo mostra o link a importar. O ID de usuário é `3971e1b2-18a3-4f83-8fa6-bf9b142ee258`.

TLS sem transporte:

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

REALITY com Vision, tomando emprestado `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 sobre TLS por uma CDN, com 2048 bytes de 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 sobre TLS:

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

HTTP Upgrade sobre TLS:

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

XHTTP sobre 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 sobre 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 sem 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/pt-br/protocols/vless/index.mdx