V2Ray Subscription Formats: Convert Base64 Subscriptions, Native JSON, and Share Links

1. Subscription URLs, share links, and native JSON

“V2Ray subscription” isn’t a single file format. When a client requests an HTTPS URL, the response might be Base64 text, a list of share links, JSON, or even a login page. Check the response body to identify the format; don’t rely on whether the URL ends in .txt or .json.

Keep the client and core distinct: v2rayN is a desktop client; v2rayNG uses the Xray core, while v2flyNG uses the V2Fly core. Importing a link only means the client recognized its text format; it doesn’t mean the current core supports every feature it declares. For REALITY or specific flow-control settings, check core compatibility instead of repeatedly encoding or decoding Base64.

2. Identify the subscription response before decoding

When inspecting a response with a trusted local tool, trim leading whitespace and check how the content begins. Subscription tokens can grant access to an account, so don’t send the full URL, response body, or QR code to an online converter. If the browser shows a CAPTCHA, login form, or error page, resolve the access issue first.

HTTP status code 200 only means the request received a successful response; it doesn’t guarantee the body contains nodes. Even valid JSON may contain only an error code and message. Identifying the content before choosing an import option is more useful than repeatedly switching proxies or changing ports.

3. Decode a Base64 subscription into share links

A common way to create a traditional subscription is to join multiple share links with line breaks, then Base64-encode the resulting UTF-8 text. Decoding reverses that process. Note the difference between standard Base64 characters + and / and the URL-safe variants - and _; the trailing = padding may also be omitted.

The native JavaScript function below is for local inspection. It processes only the input string and makes no network requests. Run it in an offline HTML page you create yourself; don’t paste a real subscription into the console of an untrusted website. UTF-8 decoding matters, or node names containing non-ASCII characters may become garbled.

function base64ToText(source) {
  const normalized = source
    .replace(/\s+/g, "")
    .replace(/-/g, "+")
    .replace(/_/g, "/");

  if (!/^[A-Za-z0-9+/]*={0,2}$/.test(normalized)) {
    throw new Error("Invalid Base64 characters");
  }

  const body = normalized.replace(/=+$/, "");
  if (body.length % 4 === 1) {
    throw new Error("Invalid Base64 length; check that the input was copied in full");
  }

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

function textToBase64(text) {
  const bytes = new TextEncoder().encode(text);
  const binary = Array.from(bytes, byte => String.fromCharCode(byte)).join("");
  return btoa(binary);
}

// Local check; the result should be true.
console.log(base64ToText(textToBase64("Subscription format test")) === "Subscription format test");

1. Pass the subscription response body to base64ToText, not the HTTPS subscription URL.
2. Split the decoded result at line breaks and remove blank lines and leading or trailing whitespace. Preserve every character within each link.
3. Check the protocol prefix on each line. Test-import one node before processing the rest in bulk.
4. To regenerate a traditional Base64 list, encode the newline-separated links with textToBase64(links.join("\n")). This won’t create a subscription URL that others can access.

After decoding the outer list, the content after vmess:// may still be Base64. That’s part of the individual node’s encoding, not a failed decode. Don’t keep decoding the entire result mechanically; handle each protocol separately.

4. How VMess and VLESS share links map to JSON fields

A common VMess share link consists of vmess:// followed by a Base64-encoded node JSON object. Common keys include add, port, id, net, host, path, and tls. This is a sharing format, not a complete configuration for the core; v indicates the share format version, not the core version.

VLESS share links usually put the user ID, address, and port in the URI body, with transport parameters in the query string. The example below uses a reserved example domain and a demonstration UUID to show how fields map; it won’t connect to a real node.

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

The VLESS example above maps to the Xray outbound snippet below. It doesn’t include inbounds, DNS, or routing, so it isn’t a complete runnable configuration. When adding it to a full config, place it in the appropriate outbounds array and verify the fields against the documentation for your core version.

{
  "tag": "proxy",
  "protocol": "vless",
  "settings": {
    "vnext": [
      {
        "address": "node.example.com",
        "port": 443,
        "users": [
          {
            "id": "00000000-0000-4000-8000-000000000001",
            "encryption": "none"
          }
        ]
      }
    ]
  },
  "streamSettings": {
    "network": "tcp",
    "security": "tls",
    "tlsSettings": {
      "serverName": "edge.example.com",
      "allowInsecure": false
    }
  }
}

• encryption=none does not mean TLS is disabled: the former is a VLESS user parameter; the latter is controlled by the transport security layer.
• Don’t add flow without a reason. The flow-control value must match the server and transport combination; not every VLESS node needs one.
• When building URI query parameters, apply encodeURIComponent to each value. To parse them, use URL and URLSearchParams to avoid decoding a value twice.
• IPv6 addresses need square brackets in a URI. Spaces, non-ASCII characters, and # in node names must also be encoded according to URI rules.

5. Why native JSON can’t always be converted back to a subscription without losing data

A single share link mainly describes one remote connection. Full native JSON may also include multiple outbounds, routing rules, DNS servers, traffic sniffing, and local listeners. Even if you can extract a VLESS link from one outbound, that link can’t restore the entire routing policy. So before converting JSON to a subscription, clarify whether you’re extracting nodes or preserving the whole runtime configuration.

Likewise, Xray and V2Fly JSON configurations aren’t interchangeable just by changing the filename. Protocol extensions, transport fields, and DNS options can differ. Removing unsupported fields may make a config parse, but it can also change how the connection works. Check the server requirements before migrating.

6. Choose the right import option in v2rayN and Android clients

Menu labels change between versions. The steps below describe common menu options and what they do; if your client uses different names, look for the equivalent of subscription groups, clipboard import, or custom configuration. Don’t paste a subscription URL into a field that accepts only a single share link, or a full JSON config into a server address field.

1. Add a long-term subscription in v2rayN: Go to “Subscription Group” → “Subscription Group Settings,” add a group, and enter the subscription URL. After saving, choose “Update subscription (without proxy)” or the equivalent update option from the subscription menu. Choose “Update subscription (through proxy)” only if your network requires a proxy.
2. Import one-time links in v2rayN: Copy the complete list of share links, one per line. From the “Servers” menu, choose “Import batch URLs from clipboard.” Check the transport type, TLS, and SNI after import, then select the server to use.
3. Update a subscription in v2rayNG: Open “Subscription Group Settings,” create a group, enter the URL, and save. Return to the list and choose “Update subscription.” To import nodes from the clipboard, use “Import from clipboard” in the add menu; don’t mix up the two options.
4. Check compatibility in v2flyNG: Before using its subscription or share-link import option, confirm that the node configuration works with the V2Fly core. If a node requires an Xray-specific feature, ask the provider for a compatible configuration; encoding conversion won’t solve the issue.

7. Common subscription conversion and import problems

The final check boils down to four steps: inspect the response body, identify the format, verify the node fields, and confirm the core runs. For TLS, outbound, and routing terminology, see the glossary. If import succeeds but you still can’t connect, use the troubleshooting guide to check logs and network settings.