Clash Subscription Import Guide: Three Import Methods and Common Format Notes

A subscription link is an HTTP/HTTPS address pointing to a remote configuration file. The client periodically requests this address, and the server responds with a YAML or Base64-encoded collection of nodes and rule sets. The link is usually generated by the proxy provider in the user dashboard, in a format like https://example.com/api/v1/sub?token=xxxx, where the query parameter carries an identity token. Sharing this link isn't a good idea — holding the link is equivalent to holding node access for that account.

Once you have the link, there's no need to open it in a browser — visiting it directly usually shows garbled text or triggers a file download, which is expected, because the response is meant to be parsed by a client program, not read as a webpage. The correct approach is to hand the link, as-is, to a Clash-family client (Clash Verge, Clash for Windows forks, Clash Meta core front-ends, etc.), which handles the request, parsing, and configuration writing on its own.

URL import is the most common method — its advantage is that updates only require the client to refresh automatically, with no need to manually replace files. Steps:

1. Open the client's "Subscriptions" or "Profiles" management page.
2. Click a button like "New" or "Import," then paste the subscription link into the input field.
3. Optionally add a recognizable label, such as the provider's short name plus plan type.
4. After confirming, the client immediately makes a request, pulls the remote configuration, and generates a local cache.
5. Select the entry in the subscription list and click "Enable" or "Select" to activate the rules and nodes.

Clipboard import is useful when you've copied a configuration snippet or link from a browser extension, chat app, or a QR code scan result, but switching between windows is inconvenient. Most desktop clients offer an "Import from Clipboard" button on the subscription page, working as follows:

1. First copy the subscription link or the full YAML configuration text to the system clipboard.
2. Switch back to the client and click "Import from Clipboard" — the program automatically detects whether the clipboard content is a link or configuration text.
3. If it's recognized as a link, the behavior matches URL import; if recognized as configuration text, it's saved directly as a local subscription without any remote update capability.

Mobile clients (such as Clash Meta apps on Android) also keep this entry point, which is especially handy when jumping in directly from another app's "Share" action, reducing manual input errors.

Local file import is for offline scenarios, or cases where a provider only offers a downloadable file rather than an online link. Common file extensions are .yaml and .yml; some older configurations are distributed as .txt or Base64 text. Steps:

1. Download the configuration file and save it locally, noting the path.
2. On the client's subscription page, choose "Import Local File" or "Open Configuration."
3. Locate and confirm the file in the system file picker.
4. The client reads the file content and parses the nodes, proxy groups, and rule fields according to the YAML structure.

URL Import

The go-to choice for daily use, supports auto-update, requires network access to the subscription domain

Clipboard Import

Convenient for cross-app handoff, recognition depends on the clipboard content type

Local File Import

Works offline, updates require manual re-import, good for emergency backup configurations

A subscription imported via URL usually has an "update interval" field in the client, measured in hours, with a common default of 24 hours. Setting the interval too short increases the request frequency against the subscription server, and some providers rate-limit or block frequent pulls, so it's best to keep the default or use at least 6 hours. The setting is typically found in the subscription entry's "Edit" dialog — look for an interval or "Auto-update cycle" input field, enter a value, and save; no client restart is needed.

If you don't want to wait for the next automatic cycle, almost every client provides a circular arrow-style "Update Now" button next to each subscription entry — clicking it triggers a fresh remote request and refreshes the node list, usually completing within seconds. If an update fails, common causes include an expired link, the network being unable to reach the subscription domain, or a conflict between the local proxy switch state and the subscription domain's policy — try temporarily disabling the system proxy before retrying.

Most subscription servers include a field called Subscription-Userinfo in the HTTP response headers, formatted like upload=xxx; download=xxx; total=xxx; expire=xxx. Once the client parses this field, it displays used traffic, total traffic, and the expiration date directly on the subscription entry, with no extra configuration needed. This is usually shown to the right of the corresponding entry in the subscription list, or in an expanded detail view, as a progress bar or "used/total" text.

Keep in mind that this data is a snapshot from the server's most recent response, not a real-time value. If you've just consumed a large amount of traffic on another device, the number shown locally won't sync until the next subscription update. If an entry never shows traffic information, it's usually because the provider isn't returning that field in the response headers — in that case, you'll need to check actual usage in the provider's own user dashboard, since the client interface can't produce this data on its own.

• When remaining traffic is low, it's worth planning ahead for renewal or replacement so nodes don't suddenly become unavailable mid-use.
• The expiration field and the traffic field are independent of each other — even with plenty of traffic left, a subscription still stops working once it expires.
• Configurations from local file import generally don't carry this information, since they skip the HTTP response header entirely.

Clash-family clients mainly accept two types of subscription content:

• Native YAML format: organized directly with fields like proxies, proxy-groups, and rules. Clash Meta (the mihomo core) extends this with additional protocol fields and rule types, such as Hysteria2, TUIC, and WireGuard. Older core versions that don't recognize these extended fields will skip them or throw errors — if the number of imported nodes looks unusually low, an outdated core version is often the reason.
• Base64-encoded node lists: common in early V2Ray/Shadowsocks aggregated share links. Some clients can automatically detect and convert these into Clash rule sets, while others require a conversion service to generate standard YAML before importing. Feeding this type of link directly into a Clash client as a subscription may fail to parse.

proxies:
  - name: "Sample-Node-HK-01"
    type: trojan
    server: example.node.tld
    port: 443
    password: "sample-password"
    sni: example.node.tld
    udp: true

Above is a minimal Trojan node field example. In an actual subscription file, entries like this repeat many times, grouped into categories via proxy-groups, and rules then decide which domains or IP ranges route through which group. There's no need to edit these fields manually before importing — the client parses them automatically. Line-by-line checking is only needed when building a custom configuration or debugging a misbehaving node.