V2Ray Subscription Formats: Base64, JSON, and Share Links

1. Distinguish URLs, encoding, and configuration data

“V2Ray subscription format” isn’t a single file standard. A typical subscription endpoint returns text over HTTPS. That text may contain multiple share links, or the entire list may be Base64-encoded. The subscription URL itself isn’t a node configuration: the client must request the URL and parse the response.

A filename doesn’t prove the content format either. A URL ending in .json may return an error page, while a URL with no extension may return valid JSON. Check the response first, then choose “Update subscription,” “Import from clipboard,” or “Import custom config.”

2. Identify and decode a Base64 subscription

A traditional link-list subscription is commonly created by placing each share link on its own line, converting the text to UTF-8 bytes, and then Base64-encoding the result. Decoding it should reveal recognizable protocol prefixes—not a complete core config.

This JavaScript demonstrates local string processing only. It accepts standard Base64 and the commonly used URL-safe alphabet. It removes whitespace from the encoded text, not characters inside share links. If the length is invalid or the decoded bytes are malformed, stop and inspect the input—don’t try repeated decoding to “fix” it.

function decodeSubscription(encoded) {
  const text = encoded.trim()
    .replace(/\s/g, "")
    .replace(/-/g, "+")
    .replace(/_/g, "/");

  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(text) ||
      text.length % 4 === 1) {
    throw new Error("Invalid Base64 text format");
  }

  const padded = text + "=".repeat((4 - text.length % 4) % 4);
  const bytes = Uint8Array.from(atob(padded), ch => ch.charCodeAt(0));
  return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
}

function encodeSubscription(linkText) {
  const bytes = new TextEncoder().encode(linkText);
  let binary = "";
  for (const byte of bytes) binary += String.fromCharCode(byte);
  return btoa(binary);
}

• If decoding reveals vmess:// or vless://, check the share links one line at a time.
• If the raw content starts with { or [, first check whether it’s JSON. Don’t Base64-decode it yet.
• If you see HTML, a sign-in prompt, or an API error, check subscription access, expiration, and the network response.
• After decoding the outer layer, a vmess:// link may still contain a Base64-encoded payload. That’s an encoding layer within the link, not a failure to decode the subscription.

3. Convert share links to JSON by mapping fields

Converting a link isn’t a matter of replacing its prefix. A common VMess share format places an encoded JSON payload after vmess://. VLESS share links typically use a URI structure containing a user ID, host, port, query parameters, and remark. Support for extended parameters varies across clients.

vless://[email protected]:443?encryption=none&security=tls&type=tcp&sni=example.com#format-demo

This fictional connection illustrates the fields; example.com is a documentation-only domain and won’t work for a real connection. Here, encryption=none is a VLESS user-level setting and doesn’t disable TLS; transport security is specified by security=tls.

This example targets Xray cores that support these fields. 10808 binds to the loopback address; 443 is the remote port. They aren’t interchangeable. This example uses the traditional tcp syntax; check the relevant core documentation for transport names and compatibility aliases.

{
  "inbounds": [
    {
      "tag": "local-socks",
      "listen": "127.0.0.1",
      "port": 10808,
      "protocol": "socks",
      "settings": {
        "auth": "noauth",
        "udp": true
      }
    }
  ],
  "outbounds": [
    {
      "tag": "proxy",
      "protocol": "vless",
      "settings": {
        "vnext": [
          {
            "address": "example.com",
            "port": 443,
            "users": [
              {
                "id": "7c9c1f0b-4bd8-4b44-8eb2-3eb2ac702783",
                "encryption": "none"
              }
            ]
          }
        ]
      },
      "streamSettings": {
        "network": "tcp",
        "security": "tls",
        "tlsSettings": {
          "serverName": "example.com"
        }
      }
    }
  ]
}

4. Convert JSON to share links: what gets lost

When exporting a share link from a full config, converters usually extract just one proxy outbound. A JSON config can contain multiple outbounds, including direct or blocked outbounds. Before converting, select the target proxy’s tag; don’t assume the first item in the array is the node you want.

routing.rules, dns, local listening addresses, and per-app settings usually aren’t included in standard node share links. Convert JSON to a link and back, and the resulting config may not match the original—even if the connection works, that doesn’t prove the routing behavior is unchanged.

1. Save a copy of the original JSON and note the outbound tag you’re migrating.
2. Compare the server address, port, identity, transport, TLS, and flow control—not just the node name.
3. Encode remarks and query parameters according to URI rules. Pay special attention to ?, &, and # in paths so they aren’t mistaken for link delimiters.
4. If the converter reports unsupported fields, stop the automatic migration and check them manually. Don’t silently drop fields and continue.

5. Repackage share links as a subscription: updates don’t come back automatically

Join multiple share links with one link per line, then Base64-encode the full text to create content for a traditional link-list subscription. This is only a snapshot, though. For a client to fetch it regularly, you’ll also need a subscription URL that you or a trusted provider manages and keeps accessible.

• Prepare the input: Keep one complete link per line, remove blank lines, and don’t encode webpage titles or explanatory text.
• Encode the text: Use UTF-8 consistently and check that remarks containing non-ASCII characters are encoded correctly. Don’t process Unicode text with methods that only support single-byte characters.
• Check the output: Decode the result and confirm that the number and order of links and their parameters are unchanged.
• Plan for updates: A static snapshot won’t change when node addresses or credentials change. Regenerate and republish the content as needed.

Native JSON can’t be turned into a subscription supported by every client by simply Base64-encoding the whole file. Encoding doesn’t change the underlying data structure. If the target import option only accepts a list of share links, a decoded full JSON config may still fail to import.

6. Verify conversion results in v2rayN and v2rayNG

Import into a separate test group first to avoid subscription updates overwriting existing manual configs. The menu names below are common examples; labels and layouts vary by version, so follow the current interface. Don’t paste a full JSON config into the subscription URL field.

1. v2rayN subscription: Open “Subscription Group” → “Subscription Group Settings,” add a test group with a trusted subscription URL, then run the update command for that group.
2. v2rayN share links: Copy the links, choose “Import bulk URLs from clipboard” in the main window, and check which group contains the new entries.
3. v2rayNG share links: Tap “+” in the upper-right corner → “Import from clipboard.” Then edit the new entry and check the server, port, and transport settings.
4. v2rayNG subscription: Add the URL under “Subscription Group Settings” in the menu. Return to the main screen, choose “Update subscription,” and confirm that the test group is being updated.
5. Native JSON: Use the custom-config import option available in your current version. First check the config parsing results in the log, then start the connection.

After starting, check three layers: first, whether the core parses the config and listens on the local port; second, whether the remote handshake succeeds; and third, whether app traffic enters the proxy and follows the expected route. Seeing a node in the list only confirms that the parser saved the data—it doesn’t replace the other two checks.

Keep three things: a secure copy of the original input, the field mapping used during conversion, and the verification results in the target client. If something goes wrong later, you can tell whether the subscription response changed, the conversion dropped fields, or local routing or port settings were modified.