When adding a configuration to a Clash client, the hardest part is often not finding the button but identifying the format of the content you have. A subscription URL, local YAML configuration, single-node share link, and proxy provider file may all contain server information, but their purposes, import paths, and update methods differ. Pasting a single-node link into a subscription field or saving a web page as YAML commonly produces errors such as “invalid format,” “configuration parse failed,” or “proxy group not found.”

Menu names vary slightly between graphical clients. Common entry points include “Configuration,” “Subscription,” “Profiles,” and “Config Files.” All of them ultimately pass the data to a Clash-compatible core for parsing. Once you understand the data types, you can determine whether to paste a URL, choose a local file, or first convert the content into a complete configuration—even when the client interface changes.

How subscription URLs, node links, and YAML files differ

Subscription URL: configuration content returned by a remote service

A subscription URL is usually an address beginning with https://. After saving it, the client sends a network request and stores the server’s response as a remote profile. When you click “Update Subscription,” the client visits the same address again to retrieve node changes, proxy-group updates, or rule revisions.

The address itself is not the configuration body. Importability depends on the HTTP response. A subscription URL that looks valid may return complete Clash YAML, encoded node-only text, a login page, an error page, or JSON. The fact that a browser can open the URL does not mean the Clash core can parse it.

https://example.com/api/client/subscribe?token=example-token

Subscription parameters often identify your account or select a client-specific format. Preserve the complete query string when copying the URL, including everything after the question mark. If the service offers dedicated “Clash,” “Clash Meta,” or “Mihomo” options, choose the format matching your current core instead of guessing compatibility from a generic link.

Single-node share link: describes one proxy node

Single-node links generally begin with a protocol name, such as ss://, trojan://, vmess://, or vless://. They describe one node’s server, port, authentication parameters, and transport settings, but typically do not include the complete proxy groups, rules, and default outbound required to run Clash.

Some clients offer “Import Nodes from Clipboard,” which converts share links into node entries; others accept only complete configurations. In the latter case, pasting a single-node link into the subscription URL field fails because that field expects to fetch a remote HTTP address. Even after conversion, the node still needs to be placed under proxies and referenced by proxy-groups and rules.

Local YAML: a configuration the core can read directly

YAML files usually end in .yaml or .yml and may contain ports, the operating mode, nodes, proxy groups, rules, DNS, and TUN settings. A complete configuration can be loaded through “Import Local Configuration” or “Open Config File.” Unlike a remote subscription, a local file does not update automatically from its original URL; after editing it, you generally need to reload it or refresh it in the client.

Here is a minimal structural example. Real node parameters should come from a trusted source; this example only illustrates how the sections relate to one another.

mode: rule

proxies:
  - name: Example
    type: ss
    server: 192.0.2.10
    port: 443
    cipher: aes-128-gcm
    password: example-password

proxy-groups:
  - name: PROXY
    type: select
    proxies:
      - Example
      - DIRECT

rules:
  - MATCH,PROXY

proxies defines connectable nodes, proxy-groups determines which outbounds users can select, and rules sends traffic to the appropriate policy. A configuration with only proxies and no usable rules or proxy groups may pass syntax validation but still fail to route traffic as expected.

Standard steps for importing a subscription URL into a Clash client

  1. Confirm which core the client uses.

    The original Clash, Clash Meta, and mihomo share broad compatibility for basic configuration, but extensions, rule types, DNS fields, and TUN options are not fully interchangeable. Many current clients use the mihomo core, so choose the Clash Meta or mihomo format provided by the service.

  2. Copy the complete subscription URL.

    Use the copy button on the subscription management page, then check that no spaces, line breaks, or explanatory text were added before or after the URL. Do not copy only the truncated text shown on the page, and do not mistake the browser’s login-page address for the subscription URL.

  3. Open the configuration or subscription page.

    Look for an entry such as “New Subscription,” “Import from URL,” or “Download Remote Profile.” Give the profile a recognizable name, then paste the URL into the remote address field. If the interface also offers a file picker, use the file-import entry for YAML files instead of placing them in the URL field.

  4. Download the profile and check its status.

    The client will access the remote address and parse the response. After a successful import, you can usually see the profile name, update time, node count, or file size. If a profile card exists but contains no content, check the update log before enabling the system proxy.

  5. Set it as the active profile and choose a policy.

    A successful import does not mean the profile is active. Select the profile, then open the proxy page and choose an outbound from a proxy group. In rule mode, traffic is assigned according to rules; in global mode, the client generally sends most traffic through the selected global policy.

  6. Enable the system proxy or TUN last.

    The system proxy works well for apps that honor the operating system’s proxy settings. TUN mode uses a virtual network interface to capture a broader range of traffic and often requires system permissions. For a first setup, verify the regular system proxy first, then decide whether to enable TUN based on the apps you need to cover.

Common Clash YAML sections and format requirements

YAML uses indentation to express hierarchy. Use spaces and do not mix in tabs. Keep a space after colons, start list items with a hyphen, and quote values containing special characters when necessary. An editor that automatically replaces ASCII punctuation can also cause parsing failures.

Node and proxy-group names must match

Proxy groups reference nodes or other proxy groups by name. If you rename a node from “Tokyo 01” to “Tokyo Main,” update every reference to the old name as well. Otherwise, the core may report that the proxy does not exist or refuse to create the proxy group while loading the configuration.

proxy-groups:
  - name: AUTO
    type: url-test
    proxies:
      - Tokyo-01
      - Singapore-01
    url: https://www.gstatic.com/generate_204
    interval: 300

A select group lets the user choose manually, a url-test group selects an available node based on test results, and a fallback group focuses on switching to the first available node in order. Exact support depends on the core version and the client wrapper. The test URL, interval, and tolerance also affect automatic selection; a single latency reading should not be treated as a long-term quality verdict.

Rules are matched in order

Clash rules are generally evaluated from top to bottom, and matching stops at the first hit. Exact domains, domain suffixes, IP ranges, and rule sets should appear where they fit the intended policy; a catch-all rule usually belongs at the end. For example, DOMAIN-SUFFIX,example.com,DIRECT sends the specified domain suffix to the direct policy, while MATCH,PROXY catches traffic that matched nothing earlier.

The policy name in a rule must exist in a proxy group or as a built-in policy. If a subscription converter changes a proxy-group name without updating rule references, the configuration may fail to import. Check both proxy-groups and rules instead of looking only at the node list.

A proxy provider is not a complete subscription configuration

proxy-providers loads a set of nodes from a remote file, which proxy groups then reference through use. A provider file normally supplies only the node collection, not the full configuration’s DNS, rules, and port settings. Importing the provider URL as a complete profile may therefore produce missing-field errors.

proxy-providers:
  remote-nodes:
    type: http
    url: https://example.com/provider.yaml
    path: ./providers/remote-nodes.yaml
    interval: 3600

proxy-groups:
  - name: PROXY
    type: select
    use:
      - remote-nodes

The remote file is referenced by the main configuration. The client first loads the main YAML, then downloads the node collection according to its provider definition. These two update layers are separate: updating the main profile does not necessarily refresh every provider immediately. The exact behavior depends on whether the client offers a separate provider refresh action.

What to check, and in what order, when a subscription import fails

Step 1: Confirm that the request returned a configuration

Start by checking the HTTP status and error type in the client log. Status 401 or 403 commonly indicates expired credentials, changed access permissions, or missing request parameters; 404 may mean the path has changed; a timeout calls for checking the current network, DNS resolution, and system time. If the response is HTML, the URL likely redirected to a login page, verification page, or error notice.

Some subscription URLs rely on a browser login session, while client requests do not automatically include that browser session. Get the dedicated URL from the service’s subscription management page instead of copying an ordinary web page address that requires a prior login.

Step 2: Identify the format of the returned content

Complete Clash YAML often includes fields such as proxies, proxy-groups, and rules. If the response is one long block of encoded text, it may target another client; if it contains only multiple protocol links, it is closer to a node collection. Switch the output format on the service page or use an import method explicitly supported by the client.

A file extension does not reliably identify the response type. A URL may not end in .yaml and still return YAML; conversely, a URL mentioning YAML may return a web page after authorization fails. Use the actual response and client log as the source of truth.

Step 3: Locate YAML syntax and field errors

When the log provides a line and column number, first inspect the nearby indentation, colons, quotation marks, and list structure. The actual cause may be before the reported line—for example, an unclosed quote on the previous line that the parser detects only on the next one. Keep an original copy before editing; changing one item at a time is easier to diagnose than deleting a large block at once.

“Field not supported” usually points to differences between cores. The configuration may use mihomo extensions, newer protocol fields, or an updated DNS structure while the client’s core is older. Update to a compatible client, choose the matching subscription format, or adapt the fields to the current core’s documentation. Do not simply delete unfamiliar options and run the result without review.

Step 4: Check whether configuration layers overwrite one another

Some clients separate subscription profiles, global overrides, merge files, and script processing into different layers. The remote YAML may be valid, yet a local override that adds a duplicate port, invalid proxy group, or outdated DNS field can prevent the final configuration from starting. Temporarily disable overrides, confirm that the original subscription loads by itself, then restore custom items one at a time.

If the import succeeds but the internet remains inaccessible, distinguish a configuration parsing problem from a connection problem. The former usually produces a clear error during loading; the latter may appear as node timeouts, DNS failures, a disabled system proxy, or an incorrectly established TUN route. Check which stage the log reaches before repeatedly deleting and re-importing the same subscription.

Subscription updates, configuration storage, and migration notes

Remote subscriptions are useful for receiving ongoing node and rule changes, but locally edited content may be overwritten during the next update. Put custom rules in the client’s override, merge-configuration, or script-processing feature when available. If the client lacks those capabilities, maintain a separate local YAML file and update its node source manually.

Subscription URLs often contain access credentials and should be stored like account keys. Mask query parameters in screenshots, logs, and support requests, and never post the complete URL publicly. When moving to another device, copy the subscription again on the new device instead of sharing the address through a public chat history.

When moving from one Clash client to another, first confirm the target client’s core and configuration-directory conventions. Basic YAML can often be reused, but the subscription list, policy selection, override scripts, and TUN permissions saved by a graphical client are client state and may not be included in the YAML. After migration, select the active profile again, check the proxy groups, and reauthorize the system proxy or virtual network interface.

Do not set the subscription refresh interval too low. Node providers and main profiles usually define a reasonable update schedule; frequent requests rarely improve anything and may trigger remote access limits. For routine use, follow the service’s recommended schedule, then refresh manually when the node list changes noticeably, the profile reports that it is outdated, or rules need updating.

Quick guide: where should this content go?

  • Starts with HTTPS and comes from a subscription management page: put it in “Import from URL” or “Remote Profile.”
  • A single line beginning with a protocol name: use the client’s node-import feature, or convert it and add it to a complete YAML file.
  • A .yaml or .yml file already saved on your computer or phone: import it as a local file; do not enter its file path in the online subscription field.
  • A provider file containing only a node list: reference it through proxy-providers in the main configuration; it cannot replace a complete runtime profile.
  • Opens to a web page, login prompt, or error notice: the response is not a Clash configuration that can be parsed directly; obtain the dedicated subscription URL again.
  • Imports successfully but the proxy page has no proxy groups: check whether the profile contains only nodes, whether the proxy groups reference valid names, and whether the profile is active.

The key to importing a Clash subscription is not trying every button repeatedly. First identify the input format, then confirm that the client core matches the configuration. A subscription URL provides remote updates, YAML describes the complete runtime structure, a single-node link supplies one connection entry, and a proxy provider is a node source managed by the main configuration. Troubleshoot in this order—request result, content format, YAML structure, core compatibility, and runtime status—to locate most import problems accurately.