What Is a Subscription Link? A Beginner's Guide
A subscription link is a single address that points to node configs, and one fetch hands your client the whole route list. This guide covers how it differs from a single node link, where to get one, how to import it on each platform, how often it refreshes, and what to do first if the link leaks — plus a checklist you can tick off at the end.
A subscription link is an https address. Your client requests it once and receives a config containing several routes. What it solves is maintenance cost: when routes are added, swapped or regrouped, you don't re-copy anything — one tap on “Update subscription” is enough.
What a subscription link is
The link itself doesn't describe encryption and carries no readable account details — it points to a text file generated on the server. The client parses that text and turns each line back into a connectable route. A link usually looks like this:
https://sub.example.com/quartz/v2/client/subscribe?token=9c1f4a7b2d
The token after the question mark decides whose subscription this is. There's no username and no login password in the URL, but anyone holding the link can pull the same route list — more on that in the leak section below. One subscription can be imported on several devices, with no cap on simultaneous connections, and the route list stays maintained on the server side.
The server returns one of two common formats. The first is a base64-encoded list of node links, one per line once decoded — the most portable option. The second is the YAML config used by Clash / mihomo, which carries proxy-groups and rules alongside the routes. Most panels let you switch the export format for the same subscription; which one you pick depends on your client.
Decoded, the content looks roughly like this — one route per line, with the display name after the hash:
ss://[email protected]:8443#Hong Kong-01
trojan://[email protected]:443?sni=jp02.example.com#Japan-02
vless://[email protected]:443?security=reality#Singapore-03Adding nodes by hand was common early on: copy a node link, paste it, connect. Once you have more than a handful of routes it turns into repetitive work, and when the server reshuffles routes the old nodes stop working — users can rarely tell whether the link expired or their own network is at fault. A subscription link hands that job to the client: the list lives on the server, and dead routes get replaced.
Worth remembering: a subscription link only gets you the config — it doesn't guarantee you can connect. Connection quality depends on route type, your local network and your ISP, not on the link itself.
How it differs from a single node link
The most common beginner mistake is adding a single node link as if it were a subscription, then blaming the client when it fails. A single node link carries a protocol prefix, and that prefix already tells you the encryption and transport: ss is Shadowsocks, vmess and vless belong to the V2Ray family, trojan runs over TLS, hysteria2 and tuic are QUIC-based. A subscription link has none of those prefixes — it's just an address. The differences, item by item:
| Item | Subscription link | Single node link |
|---|---|---|
| Contents | A full route list, optionally with groups and routing rules | The complete parameters for one route |
| Form | An https address returning base64 text or YAML | A link with a protocol prefix such as ss, vmess, trojan, vless, hysteria2 or tuic |
| Updates | Server-side changes take effect on the next fetch | Fixed; you need a new link when routes change |
| If leaked | Anyone can pull the entire route list | Only one route's parameters are exposed |
| Best for | Long-term use and syncing across devices | Testing a single route ad hoc |
The short version: for everyday use, pick the subscription link — no more re-copying every time a route changes. A single node link is better for a quick test of whether one specific route works.
Where to get a subscription link
The subscription link only appears in your user panel — it's never sent by email and never bundled into an installer. The panel usually offers both the link and a single-node QR code; the QR code is just another rendering of the same link, and scanning it imports exactly what copying would. Getting the link takes five steps:
- Sign in to the panel. Registration only asks for a username and password — no email address, and there's no email verification step.
- Open the subscription or plan area and check your current plan's data allowance and expiry date first.
- Choose the export format. Plain base64 suits clients such as v2rayN, v2rayNG and Shadowrocket; pick YAML for Clash / mihomo.
- Copy the full address. The token parameter sits after the question mark — drop one character and you'll get an error page or a blank one.
- Paste it into the client and connect once straight away to confirm the routes work before you touch routing rules.
The service specs behind that subscription, in four lines:
110+
Countries / regions covered
160+
Number of routes
Unlimited
Simultaneous devices
14 days
no-questions-asked refund
How to import a subscription link into your client
Menu names differ between clients, but the steps are the same:
- Open the client's subscription or profile page and look for an entry such as “Add subscription” or “New remote profile”.
- Paste the link and give the subscription a name you'll recognise — naming it after the device works well.
- Save, then update once and wait for the node list to appear.
- Connect to one route, then go back into settings to set the update interval and routing mode.
Import entry points by platform
| Platform | Common clients | Import path |
|---|---|---|
| Windows | v2rayN、Clash Verge | “Subscriptions” → Add, or “Profiles” → New remote profile |
| macOS | ClashX、sing-box | “Profiles” → Managed profiles → Add |
| iOS | Shadowrocket、Stash、sing-box | The “+” at the top right of the home screen, type Subscribe |
| Android | v2rayNG、NekoBox | Side menu → “Subscriptions” → Add |
| Linux | sing-box、mihomo | Written into the config file, then loaded by the CLI or a system service |
On iOS, clients need an App Store account from outside mainland China to download — that step has nothing to do with the subscription link, and once the app is installed the import flow matches other platforms. The other common difference is format: Clash-style YAML already ships with groups and routing rules, so it runs by rule straight after import, while base64 carries routes only and leaves routing to the client. Some clients accept only base64, others only YAML — when an import fails, check the format first instead of reinstalling the client over and over.
How often should it update
The subscription content is generated server-side and the client pulls it at whatever interval you set. A common choice is every 12 or 24 hours; the exact options depend on your client.
Three moments call for a manual update: the route list in the panel doesn't match what the client shows, you're about to switch to another region, or the device has been off for a long time and just came back on. Most clients display the last update time, which tells you whether the change has taken effect.
Don't push the interval down to a few minutes. Every fetch carries the token, so a very high frequency buys you nothing and may get rate-limited by the server. What's fetched is plain-text config, not plan data, so updates don't eat into your allowance.
Some clients tuck “Update subscription” into the route list's dropdown, others put it on the settings page; if you can't find it, check whether the client splits subscriptions and profiles into two separate screens.
Updating a subscription only refreshes the route list inside the client; connections already established are usually unaffected. The step that really needs a fresh handshake is switching routes.
What to do after a link leaks
The token in a subscription link works like a credential. Paste the link into a public group or forum, or upload it to an online subscription converter, and you've handed over the entire route list — someone else can burn your data allowance, and the route parameters become public.
- Reset the subscription link in the panel; the old address stops working immediately.
- Re-import the new link on every device and delete the old subscription entry.
- Check recent data usage for anything unexpected.
- If the link ever went out through a chat app or a support ticket, clean up the message history while you're at it.
After a reset the old link is dead, but nodes already saved in a client that imported it won't disappear on their own — delete that subscription manually, or the client will keep trying to connect with the old config.
Online subscription converters receive the full link, token included. When you need a different format, use the client's own export feature first, or a converter running locally.
Common errors and fixes
These come up most often, and working through them in order usually pins the cause down within minutes:
- The browser shows a wall of garbled text. base64 text was never meant to be read by humans — if you get content back, the link is valid.
- Zero nodes after import. Usually the wrong format: YAML imported as base64, or the other way round.
- Updating returns an error page or a blank one. The link got truncated and the token is incomplete — copy it again.
- It updates but won't connect. Confirm the plan is still valid, then try another route to rule out a single-route problem.
- Some sites won't open once connected. Check whether you're in global or rule mode — a routing rule may be sending that domain out over the direct connection.
- Certificate or clock errors. TLS handshakes fail when the device clock drifts too far from network time; syncing the system time fixes it.
- DNS leaks. If you've edited DNS settings by hand, domain lookups may go out over the local network; when in doubt, hand DNS back to the client defaults.
On a first import, if your local network can't reach the subscription address directly, add a single node manually to get the first connection up, then come back and update the subscription.
Pre-import checklist
Tick these nine off before you start and most import problems never happen:
- ✅ The subscription link lives in a password manager or a note only you can open.
- ✅ Every device was updated manually once after import, and the node count matches the panel.
- ✅ The update interval is set to 12 or 24 hours, not a few minutes.
- ✅ The client version matches the subscription format — base64 and YAML aren't mixed up.
- ✅ The routing mode fits the job: global when everything should go through the route, rules for everyday use.
- ❌ Pasting the subscription link into public groups, forums or screenshots.
- ❌ Pasting the subscription link into an online converter you know nothing about.
- ❌ Adding a single node link as a subscription, then reinstalling the client when it fails.
- ❌ Resetting the link first when an update fails, instead of checking format and network first.
A subscription link is only the entry point — what shapes the experience is still route type and whether the plan fits how you use it. Keep the link safe, settle on an update rhythm, and all that's left is picking routes by scenario.