Clash latency tests explained: Why low ping doesn’t mean fast downloads

Learn how url-test and client latency checks work, what latency, bandwidth, packet loss, and congestion mean, and how to judge real-world performance.

Clash latency tests measure a single probe request

In most Clash clients, the latency shown next to a node comes from the core sending an HTTP or HTTPS request to a test URL through that proxy. The endpoint often returns 204 No Content, with no response body, making it useful for checking whether the expected response arrives. This isn’t the round-trip time from an ICMP ping to the proxy server, nor does it tell you how long a file download will take.

What can contribute to a probe’s response time?

  1. Connecting to the proxy. If the node address is a domain name and there’s no cached result, it may need to be resolved first. A new connection also takes time for the transport and proxy protocol handshakes.
  2. Reaching the destination through the proxy. How the test domain is resolved depends on the core, protocol, and configuration. With HTTPS, the request also needs to establish a TLS session with the destination unless an existing connection can be reused.
  3. Waiting for the test server to respond. The route from the proxy’s exit to the destination, server processing time, and queuing along the way all affect the result. Once a small response arrives, the test usually doesn’t keep transferring data to measure throughput.

These are possible sources of delay, not a universal timing formula used by every version. Caching, connection reuse, and implementation details can all affect the reading. Even with the same subscription, two clients may use different test URLs, timeouts, or timing methods, so their millisecond readings shouldn’t be compared as a simple ranking.

url-test node selection vs. manual latency tests

url-test is a proxy group type. It probes candidate nodes based on the group’s settings and uses the latency results to select a node automatically. Clicking “Test Latency” in a client usually starts a probe for one or more nodes on demand. The button and test URL are client-specific and may differ from the URL configured for an automatic group. Check the active configuration and the time of the latest test rather than relying on the numbers in the list alone.

FieldWhat it means
urlProbe target. Changing the URL changes the route being tested. Choose an endpoint that is reliably reachable and returns a small response.
intervalInterval between scheduled probes, in seconds. For example, 300 means 5 minutes; it is not the request timeout.
toleranceLatency tolerance, in milliseconds. For example, a value of 50 helps prevent frequent switches when a candidate is only a few milliseconds faster; it does not guarantee latency below 50 ms.
lazyIn mihomo configurations that support this field, enabling it can skip scheduled probes while the group is unused. An old value in the list doesn’t mean it was measured just now.

A timeout or failed test in the client doesn’t necessarily mean the node is down. First try reaching the actual service through that node, then test the same probe URL with another node. If several nodes fail only on the same URL while real-world access works, check the probe endpoint, DNS resolution, and timeout settings first.

Why low latency can still mean slow downloads

Latency tells you how long it takes to get a response; throughput tells you how much usable data arrives per second. A small response can arrive before congestion becomes noticeable, while a sustained transfer is affected by egress limits, available bandwidth, receiver capacity, and network queues. Even if an idle probe takes just 60 ms, queues can build up during a download and add hundreds of milliseconds of delay.

  • Bandwidth bottlenecks: Gigabit broadband at home only describes the ceiling of your local access connection. If the proxy’s egress, an interconnection link, or the destination server has less capacity, that segment will limit your download speed.
  • Packet loss and retransmissions: A short probe may not encounter packet loss, while a long-lived connection is more likely to need retransmissions. TCP-based transfers may also slow down as congestion control reduces the sending rate, causing speed fluctuations or intermittent stalls while page resources load.
  • Different routes and destinations: The test endpoint and the service you use may be in different data centers or take different interconnection routes. A fast response from the test server doesn’t mean the service server will be fast too.
  • Peak-hour congestion: A link that’s idle at midday may be saturated by shared traffic in the evening. If latency becomes more variable while throughput drops, congestion is worth investigating first, but those symptoms alone won’t identify which part of the route is responsible.

For example, on the same destination, node A returns a 60 ms probe and takes 40 seconds to download 100 MB; node B returns a 150 ms probe and takes 10 seconds for the same file. Using decimal units, that’s about 20 Mbps for A and 80 Mbps for B. These figures are for illustration, not measured node performance. Node B is faster for large downloads; for frequent interactions, also consider response times in the actual app rather than drawing a conclusion from these two downloads alone.

Test node performance with real-world traffic

  1. First, check how traffic is routed and which outbound is actually used. In the client’s “Connections” or “Connection details” view, check the destination domain, matched rule, and proxy chain. The exact labels depend on the client. For an explicit proxy, make sure the app’s port matches the configured mixed-port—for example, use 7890 only if the configuration specifies 7890. With TUN, check whether the app’s traffic appears in the connection list. Seeing the TUN switch enabled doesn’t mean every connection is going through the proxy.
  2. Test one variable at a time under consistent conditions. Use the same device, network, and test URL. Probe each node five times and record the median, highest reading, and number of failures—not just the lowest result. After switching nodes, start a fresh connection so the browser doesn’t keep using an existing one. Don’t measure idle latency while downloading. To observe queueing under load, run a separate test and label it clearly.
  3. Then measure real-world throughput. Use the same test server and a sufficiently large file for each node, avoiding local cache where possible. Repeat three times per node and record the completion time or the steady-state rate. A single-file test and a multi-connection speed test create different workloads; if the tool switches servers or adjusts concurrency automatically, lock those settings before comparing.
  4. Retest at the times you usually use the service. For example, run one round at 14:00 and another at 21:00. If the same destination is consistently slower in the evening, cross-check with a second service. If only one site is slow, check the site and route to the proxy exit first. If multiple nodes and destinations are slow, check local Wi-Fi, background syncing, or a shared access link.

Choose a node for the task, not by ranking milliseconds

For browsing, focus on the first response and key resource load times on the actual site. For large downloads, look at sustained throughput and interruptions. For voice calls or meetings, check jitter and packet loss in the app’s own stats. A single HTTPS probe can’t replace a media test in a meeting app, especially when the app uses UDP and the probe takes a different transport route.

Keep url-test in the default group to filter out obviously unhealthy candidates. For meetings or long downloads, first find nodes that stay stable during the hours you typically use them, then pin the outbound in a manual selection group. If latency readings are close, favor the node with fewer failures and more reliable performance on real requests. If the latency ranking doesn’t match your experience, trust the route the app actually takes and repeatable test results.

Download the latest version of Clash