What url-test actually measures

Policy groups breathe between your rules and the underlying proxies list. A url-test typed group behaves like an automatic selector whose decision function is wired to periodic HTTP latency sampling. Every handful of seconds the core probes each enumerated member toward the configured url, updates an internal leaderboard, optionally applies a tolerance hysteresis gate, then pins the quickest healthy outbound until topology changes materially.

Crucially, url-test prioritizes responsiveness to whichever destination you nominate for probing, not magically to every SaaS handshake you visit later in the browser. Operators therefore treat probes as calibrated stand-ins—good enough when every node lands in comparable regions relative to realistic targets you care about.

Keep select layers above url-test Nested designs almost always expose a manual select group whose members include the url-test group plus named regional pools plus DIRECT when you commute between networks whose carrier policies punish constant probing differently.

url-test versus select, fallback, and load balance

select is ideal when you relish explicit control—for example switching HBO regions by hand—even if that violates automatic optimization. Url-test excels when redundancy matters more than ritual inspection: let the ladder reorder itself nightly as providers churn nodes silently.

fallback consumes the proxies array strictly in order until an active outbound passes probes, drifting forward only once failure semantics trigger. Fallback mirrors operator intent better when you explicitly rank providers and never want reordering surprises. Url-test hunts for statistically faster paths at the recurring cost of background GET storms.

load-balance sprays sessions across buckets for throughput experiments; seldom should beginners mix balanced clusters with naive url-test probing without understanding hashing implications. Maintain mental clarity: latency gaming belongs to url-test, preference ordering stays with fallback.

Minimal YAML for a sane url-test stanza

Below is an intentionally compact excerpt showing how proxy-groups references named members that must already appear under proxies—whether handwritten or merged from subscriptions. Indentation-sensitive YAML forbids sloppy tabs on mobile editors; duplicate group names collide during merge and trigger reload failures.

proxy-groups:
  - name: "AUTO_LATENCY"
    type: url-test
    proxies:
      - "Tokyo-alpha"
      - "HongKong-beta"
      - "Singapore-charlie"
    url: "https://www.gstatic.com/generate_204"
    interval: 300
    tolerance: 50
    lazy: true

Expand the proxies array with whichever labels your subscription emits after deduplication routines run. Duplicate tags often appear when converters paste multiple RAW lists—you may still reference them verbatim as long as the parser accepts them upstream.

Choosing probe URLs people actually unblock

The url line is not ceremonial: any TLS handshake quirks, captive portal interception, ISP HTTP rewrite, or geoblocking will poison perceived latency unfairly despite a node actually performing admirably elsewhere. Lightweight 204/No Content endpoints favored by CDN edges remain popular because payloads stay microscopic and seldom carry cookies.

Security policies on corporate WANs occasionally strip unfamiliar destinations; swapping to HTTPS mirrors hosted beside your sanctioned productivity stack lowers false negatives. Traveling teams sometimes maintain two clones of the url-test stanza keyed by GEOIP-triggered mixin patches so domestic Wi-Fi skips overseas probes destined to flap.

Steer clear of pages that penalize scripted GET bursts Services that aggressively rate-limit datacenter footprints can mark health checks as abusive. When logs show intermittent 403/429 responses, abandon vanity endpoints and relocate to forgiving infrastructure you control—or accept direct ICMP-like logic via proxies that disallow HTTP probes entirely through manual fallback groups.

Interval engineering, tolerance, and lazy warmup

interval is expressed purely in seconds. Lower intervals converge faster during instability but chatter more radios on laptops tethered over cellular—it is reasonable to widen intervals past five hundred seconds on battery-constrained commuter tablets while keeping aggressive probing on workstations attached to ethernet.

tolerance absorbs jitter: if challenger node B trims only eighteen milliseconds versus incumbent A inside a sixty-millisecond cushion, skip migration. Narrow tolerances flirt with needless churn reminiscent of frantic Wi-Fi steering; ludicrously wide tolerances freeze you on degraded paths after genuine improvements appear.

Boolean lazy deserves nuance beyond reading “delay tests until needed.” Profiles that nest dormant url-test groups behind rarely triggered rules seldom benefit from pounding probes overnight. Conversely, dashboards that visualize standing latency before clicks happen want false to keep charts warm; trading battery for transparency is deliberate.

Wiring selectors, rules, and debugging visibility

Typical authoring stacks resemble WORLD select → AUTO_LATENCY url-test → raw nodes. Casual users tap WORLD entries in GUI dashboards; power users scripting API calls hit the same names through the external controller. Beneath MATCH rules, referencing WORLD instead of naked nodes isolates refactoring pain when proxies rename after subscription rotations.

Our YAML routing playbook clarifies overarching rule sequencing if url-test behaves yet traffic still egresses unexpectedly because higher DOMAIN rules hijack packets first. Conversely, latency logs may shout success while sniffing anomalies stem from unrelated DNS interplay—borrow patterns from dedicated DNS troubleshooting before blaming url-test jitter alone.

proxy-groups:
  - name: "WORLD"
    type: select
    proxies:
      - "AUTO_LATENCY"
      - "US_STREAMING_FIXED"
      - "DIRECT"

Once stacked, tighten validation by tailing structured logs referencing each member’s handshake times. When metrics disagree with GUI gauges, correlate whether the overlay polls cached numbers versus live controller deltas.

Proxy-provider health checks are complementary, not identical

Subscription blobs often declare health-check blocks that prune hopeless nodes ahead of YAML merge. Url-test layering still merits separate tuning because aggregator dedup may retain borderline outliers that degrade user sessions though they technically answer probes to provider-chosen anchors.

Think of upstream health pruning as sanitation on the ingress conveyor belt, whereas url-test is the dispatch algorithm dispatching sanitized boxes onto departing trucks matched to SLA expectations. Maintain both tiers rather than pretending one substitutes for the other after large subscription imports.

What GUIs typically expose versus raw YAML surgeons

Desktop shells like Clash Verge forks or Fluent readers often visualize url-test memberships with badges denoting latency and success ratios. Tweaking intervals through sliders may round awkwardly versus surgically keyed integers in YAML patches; mixin workflows let advanced authors pin canonical numbers while dependents inherit theme-specific overrides.

Mobile experiences vary: some wrappers hide tolerance entirely unless you descend into auxiliary editors—document personal defaults externally so onboarding yourself six months later is not archaeology. Whenever GUI round-trips threaten to stomp handwritten keys, escalate to mixin layers or guarded patch files instead of endlessly diffing regenerated configs.

Patterns that survive roaming, gaming, and split payroll traffic

Roaming commuters often segregate tethered presets with elongated intervals paired with forgiving tolerance so trains skipping towers do not immediately demote workable nodes exhibiting brief ping spikes.

UDP-heavy workloads such as jitter-sensitive voice chat still ride through whichever TCP-oriented HTTP probe crowned a winner earlier; reconcile expectations by spotting dedicated fallback groups for RTP flows when asymmetric routing surfaces.

Corporate split payroll stacks may demand finance domains routed through static nodes while discretionary browsing rides AUTO_LATENCY nests—compose explicit DOMAIN rules atop merged lists before blaming url-test jitter for ledger timeouts.

Troubleshooting quick reference when url-test spirals

Symptom What to investigate
Winning node rotates every probe Raise tolerance, lengthen interval, inspect noisy Wi-Fi contention, swap probe URL targeting stable CDN POPs
Every member flagged failing Malformed URL, captive portal rewriting HTTPS, ISP blocking destination, proxies requiring splice/SNI quirks not mirrored by simplistic GET probes
Healthy probe yet apps stall Rules referenced different group aliases, QUIC bypasses skipping proxy path, fragmented MTU misery unrelated to latency scoreboard
GUI shows stale latency Lazy groups idle until invoked, dashboards caching metrics, mismatch between clash-api polling interval and YAML interval knobs

When uncertainty persists despite green probes, escalate to granular logging walkthroughs that interpret match chains—our rule tracing guide pairs naturally with disciplined url-test tuning.

Frequently asked questions

Can I reuse the same probe URL everywhere?

Yes mechanically, mindful that diverse member geographies perceive identical endpoints differently—consider regional mirrors when tuning for APAC-heavy graphs versus continental Europe.

Does url-test obey policy-group exclusive locks?

GUI-specific exclusive modes remain orthogonal constructs that override simultaneous membership assumptions; reconcile documentation for your shell because stray exclusivity hooks can unintentionally mute alternates despite healthy probes.

Should I disable lazy on gateways serving LAN clients?

Gateways usually prefer continuous probing so dependents never inherit cold-start penalties; evaluate sleep schedules on low-power routers because aggressive intervals shorten flash endurance on bargain hardware.

Upstream docs and iterative validation

Field validation tightens alongside mihomo releases; keep release notes pinned whenever CI pipelines pin cores. Automated schema linters seldom catch logically silly tolerances—they still demand human rehearsal through staged reload loops.

Closing synthesis

Url-test is the humane automation layer bridging overwhelming subscription noise and brittle manual picks. Harmonize probe realism, pacing intervals for your hardware realities, wield tolerance deliberately, and articulate selector stacks narrating failover stories maintainers comprehend months later alongside evolving rule palettes.

Many minimalist accelerators trumpet one-tap brilliance yet obscure how health checks reconcile with nuanced routing—they either omit transparent YAML entirely or trap power users behind unsynchronized sliders that fight hand-authored patches nightly. Transparent Meta-first clients paired with curricula like ours keep parity between GUI convenience and reproducible merges, sparing you blackout periods after every vendor refresh cycle.

→ Download Clash for free, pick an actively maintained Meta build, pair it with mixin-friendly editors, import your subscriptions, drop in the url-test stack above, reload once, then watch dashboards confirm latency leadership without juggling opaque auto toggles buried three menus deep.

Deepen foundational routing instincts via the broader YAML policy group guide, then loop through diagnostics in the MATCH logging primer whenever probing looks perfect yet packets disagree.