Who This Article Is For

You already imported a subscription into Clash Verge Rev on Windows, routing works, yet the UI keeps bouncing between nodes. Live video buffers when the “fastest” hop changes mid-session, games spike when an url-test winner rotates, and your mental model of “auto” no longer matches reality. This tutorial is deliberately narrow: it only explains how proxy-groups of type url-test behave in the mihomo core that Verge Rev embeds, and how to adjust interval, tolerance, lazy, and the health-check URL so automatic picks calm down. It is not a repeat of the full rules essay—read the rules deep dive when you need match semantics—or the everyday dashboard tour in the Verge Rev usage guide; those pieces cover scope this page intentionally skips.

Expect YAML-level thinking. Verge Rev can merge edits through a GUI Patch without your re-pasting the entire provider file, but the vocabulary—url-test, nested selectors, interval measured in seconds, tolerance in milliseconds—comes straight from upstream docs. If you have never opened the profile pane after install, complete the Windows install walkthrough first so reload paths and backup habits feel familiar.

What url-test Actually Optimizes

An url-test group is not a speed test for Netflix, Steam, or your bank. It is a periodic health measurement from each candidate proxy to the probe endpoint you declare—typically a small HTTPS URL—and the core ranks members using those samples. Whichever child proxy returns the best cumulative score within the rules of the scheduler becomes the active outbound for traffic that references this proxy-groups name. That distinction matters: a node that looks incredible against a generic cloud front can still drag on the particular CDN edge your 4K stream pulled, and two nodes within a few milliseconds on the probe can alternate endlessly if your tolerance is tight and Wi-Fi jitter is lively.

Users describe the symptom as “policy group jitter”: the log shows outbound chains reshuffling without you touching the UI. Often the engine is doing what you asked—re-evaluating on every interval tick—but the workload you care about wants continuity more than marginal latency savings. Understanding that gap prevents futile chasing of “better” subscriptions when the fix is a few numeric knobs or a manual select pin for sensitive apps.

Read Your Profile: Find Every url-test Group

Open the running configuration Verge Rev feeds the core—not just the subscription download on disk if merging changes the story. Scan the proxy-groups list for entries where type: url-test. Note three relationships: which rules lines send traffic directly to that group name, which parent select groups include it as a child, and whether the group itself embeds other groups recursively. A renamed group breaks references silently until reload throws parser errors; duplicate labels from merged providers produce “why is my click ignored” mysteries because the UI binds to a different identifier than the rule expects.

Write down, on paper or in notes, the human label your provider uses—Auto, ⚡ Auto-Best, regional autos—and map each to the YAML name. Later, when you apply a Patch, you will target that canonical name. If you maintain multiple profiles for travel versus home, repeat the inventory per file; autos tuned for datacenter probes may need different tolerances than lightweight mobile bundles.

While reading, glance at sibling entries: pure select groups are where manual pinning lives. Many stable setups combine both—an auto group for background web fetch, a selector for the streaming chain—then point rules intentionally so bursty traffic never crosses the auto path twice unnecessarily.

Health-Check URL: Pick Something Honest

The url field under url-test (sometimes paired with an expected HTTP status) defines what “healthy” means. Vendor defaults optimize for reachability inside their network, not your living room Wi-Fi. If the URL sits on a domain your resolver handles oddly under fake-ip mode, or if it rides a CDN that returns fast for ICMP-shaped probes but far from your actual egress city, the ranking misleads you. Swap the probe only after asking whether all nodes can complete a TLS handshake to the replacement without violating acceptable use; tiny static endpoints on well-known clouds are common choices precisely because they are boring and symmetric across regions.

When every probe starts failing, resist the urge to mash reload: read core logs for TLS errors, HTTP 403 loops, or captive portal HTML. Café networks and hotel Wi-Fi break automated checks before they break manual browsing because the probe never completes the splash redirect. In those environments, automation will hunt forever; switch to a manual select or pause auto groups until you verify raw connectivity outside Clash.

If you suspect DNS divergence between probe and app traffic, align your experiment with the DNS section of the profile—mixed enhanced-mode settings and inconsistent nameserver hierarchies skew both probes and real flows. Cross-check against the Verge Rev usage article when logs mention circular resolution; this url-test guide assumes DNS already behaves coherently for a baseline test host.

interval: How Often the Core Re-Ranks Proxies

interval sets the seconds between scheduled measurements for members of the url-test group. Lower values react quickly when nodes fail; they also amplify noise—every modest Wi-Fi wobble becomes a reordering event if other settings are aggressive. Higher values trade responsiveness for calm: a bad hop may linger slightly longer on paper, yet streams stop seesawing because the winner stays pinned across several probe cycles.

Practical Windows desk setups often land in a middle band: fast enough that a dead upstream does not stick for minutes, slow enough that a 30-second latency fluctuation does not reconfigure the world. There is no universal magic number because your subscription size, CPU load, and whether you run TUN versus system proxy all change how expensive each sweep feels. Start by doubling a vendor default if you observe oscillation every few seconds, then watch a real workload for five minutes rather than trusting a one-off latency button in isolation.

Remember that interval interacts with UI-driven “speed test” buttons: manual bursts may still fire outside the schedule depending on client implementation, but steady-state automation follows the YAML clock. If you merge multiple definitions for the same logical group incorrectly, you might accidentally inherit two intervals—another reason to verify merged output after each subscription refresh.

tolerance: Hysteresis Against Millisecond Whiplash

tolerance is the hysteresis gate measured in milliseconds. A challenger must be faster than the incumbent by more than tolerance before the group switches its active child. Set it near zero and two nearly identical nodes trade places whenever jitter crosses hairs. Set it too high and a genuinely superior path waits too long to take over after an outage heals—though in practice many users overweight instantaneous optimality and underweight session stability.

When diagnosing policy group jitter, increase tolerance first before you touch more exotic strategies. Pair that change with a slightly longer interval if probes still correlate too tightly with background radio scans on laptops. Document the pair you chose; reverting weeks later without notes wastes time.

Competitive gaming and voice channels illustrate the trade-off vividly: microseconds matter for fairness, yet route churn mid-match feels worse than a stable 25-millisecond path. If your titles ride UDP through TUN, stability often beats nominal TCP probe wins—verify against gaming-focused routing guidance when QUIC or anticheat enters the picture.

lazy: Probe Only When the Group Earns Traffic

The lazy boolean changes whether health checks for that url-test group run on idle timers or defer until the group actually carries flows. With lazy: true, background churn drops: measurement work begins when you steer traffic through the auto path instead of every interval while you are elsewhere. That suits laptops that spend hours on direct domestic browsing with only occasional foreign bursts, because you stop paying probe tax during long idle stretches.

With lazy: false, the group stays warm: rankings update periodically even if you have not selected that chain recently. Use that posture when quick failover matters—think always-on monitoring profiles—or when nested selectors might land on the auto child without warning and you need fresh scores ready. Neither choice fixes a bad probe URL; they only modulate when the engine asks the question.

Some users pair lazy auto children with explicit selectors for first-hop choice: you touch the selector when starting a session, lazy url-test maintains the subtree afterward. Sketch the control plane on paper before editing so you do not strand a lazy group behind a rule that never references it—if nothing triggers traffic, lazy mode may defer discovery longer than you expect when testing.

YAML Shape You Expect Under proxy-groups

A minimal illustrative skeleton—values are placeholders, not prescriptions—shows how fields group together conceptually in mihomo-era configs:

proxy-groups:
  - name: "AUTO-STABLE"
    type: url-test
    proxies:
      - Node-A
      - Node-B
      - Node-C
    url: "https://example.com/generate_204"
    interval: 120
    tolerance: 80
    lazy: true

Real files add more keys—fallback chaining, filters, Unicode names—and provider merges may reorder blocks. Treat the snippet as a checklist, not copy-paste gospel; validate indentation because YAML mistakes surface as abrupt core restarts and scary log banners. When unsure, diff the merged runtime view before and after a single edit.

If your subscription ships multiple auto groups for separate regions, tune each independently. A tolerable interval in Tokyo may be wasteful for a tiny Latin America pool with three nodes; symmetric defaults hide that imbalance until you graph switching frequency in logs during a stress hour.

Applying Changes in Clash Verge Rev: Patch Versus Raw Edits

Provider updates love to stomp hand-edited subscription copies. Clash Verge Rev mitigates that with merge patches—surgical YAML fragments layered atop the imported profile so your url-test knobs return after every refresh. Learn the exact pane names in your build; terminology shifts slightly across releases, but the workflow persists: edit merge rules, reload core, confirm the effective config shows your numbers, then run a targeted connection test.

Patches shine when you adjust two or three numeric fields on known group names. They fail gracefully when names drift—after a vendor rename, your patch no longer attaches, and automation quietly reverts until you notice. Add a personal checklist after each subscription refresh: confirm group labels, revalidate patches, and snapshot logs if you are mid-travel.

Raw file edits remain valid for fully user-authored profiles or Git-managed configs. They trade convenience for control: you see the entire document, you version it, and you accept manual merges when upstream templates change. Pick one strategy per profile; mixing forgotten duplicates—one patch layer plus one manual file pointing at the same logical group—invites contradictory intervals competing in ways that take longer to debug than to read ten extra lines of YAML.

Windows-Specific Realities: Sleep, Wi-Fi, and TUN

Notebooks suspend, radios roam, and TUN adapters occasionally linger in odd states after resume. Each event perturbs probe timing independent of your provider’s average quality. That is why desk users and road warriors rarely share one url-test recipe: travel profiles may favor higher tolerance and lazy mode to mask transient NIC wake spikes, while tethered Ethernet setups can afford tighter intervals without visible churn.

Corporate Wi-Fi with transparent proxies sometimes answers probe URLs differently than general HTTPS browsing paths. If only automations fail, capture a short connection log excerpt and compare the domain resolved during probes versus the page you load manually. The mismatch tells you whether to relocate the probe or abandon automation for that SSID entirely during work hours.

System proxy mode and TUN shift which flows participate in resolver drama—UDP DNS, QUIC, and loopback cases differ. If you bounce between capture modes per the Verge Rev modes guide, revalidate url-test after each switch; a tuning that felt stable under WinINET may flutter under virtual adapter captures or vice versa when split routes reorder.

When Manual select Beats url-test

Automation excels when you want hands-off resilience across many similar nodes. It struggles when session stickiness matters more than average latency: logged-in CDNs, anti-fraud heuristics, long-lived HTTP/3 connections, or broadcast ingest protocols that punish mid-stream path changes. In those moments, pin a select group—even if it references the same underlying proxies—and point sensitive rules there. You lose automatic failover until you click again, but you gain predictable egress identity.

Another signal to switch tactics is observability: if you cannot find a probe that correlates with user-visible quality, stop optimizing numbers and admit the measurement is wrong for the task. Provider communities sometimes publish recommended probes per region; treat those as hints, not law, and validate with your own traceroutes when incidents repeat.

Hybrid designs work: keep url-test for bulk web fetch, maintain parallel selectors for “Streaming,” “Games,” or “Banking,” and never let auto groups sit in front of workflows where TLS session reuse spans minutes. The YAML complexity is worth it when tickets stop complaining about “random disconnects every ninety seconds.”

Verification Loop: Prove Stability With Real Traffic

After any change, avoid judging solely by colored bars. Load a long YouTube 4K sample, join a voice channel, and copy a large file while watching Verge Rev’s connection panes. Count how often outbound chains swap without manual input. Ideal behavior shows rare switches aligned with genuine failures, not rhythmic dancing on a quiet line.

If oscillations persist, iterate in single-variable steps: adjust tolerance alone, then interval alone, then probe URL—never all three simultaneously unless you enjoy unreadable postmortems. Save console excerpts with timestamps when opening community threads; volunteers diagnose structured evidence faster than adjectives.

When numbers look sane yet apps still stall, return upstream: confirm subscription health, verify a sibling device on the same network behaves, and rule out ISP bufferbloat independent of Clash. url-test cannot fix a router drowning in retransmits.

Frequently Asked Questions

Does a lower interval always mean a better experience? No. It reacts faster but can magnify jitter; raise interval when flapping dominates responsiveness concerns.

Is tolerance the same as timeout? No. Timeout governs how long a single probe waits; tolerance is the margin required before the core abandons the current winner for a slightly faster peer.

Can I mix lazy and non-lazy url-test groups? Yes. Different groups may use different strategies according to how often each path should stay warm.

Will Patch survive a subscription URL rotation? The merge layer survives refreshes, but if the vendor deletes or renames groups, your patch targets nothing until you rename fields to match.

Should newcomers avoid url-test entirely? Not necessarily—respect automation, learn its limits, and keep selectors handy for sessions that punish movement.

Closing Thoughts

Tuning url-test under proxy-groups is how you tell mihomo to stop confusing “milliseconds on a probe” with “happiness for my real workload.” Clash Verge Rev simply exposes that contract honestly on Windows, whether you edit merged YAML or layer a Patch after each provider update. Many closed clients hide the knobs entirely or lock sane hysteresis behind paid tiers, which feels convenient until your only lever is “reinstall and pray.” Commercial VPN apps also tend to consolidate failover inside opaque servers—fine until you need to prove whether jitter comes from the tunnel or the café captive portal. The Clash ecosystem trades hand-holding for inspectable config: once you align interval, tolerance, lazy, and the health-check URL with how you actually browse, auto groups stop sabotaging streams and games without surrendering the resilience that drew you to automation in the first place. Grabbing maintained builds from the project’s official distribution channels keeps that transparency intact compared with repackaged forks of uncertain lineage.