1 Why subscription refresh tuning is its own topic
A mis-tuned subscription loop creates two unrelated pains. First, you hit the airport CDN too aggressively—token throttles, vague rate limits, or extra billing on metered egress. Second, your desktop client keeps popping “updated” banners or flashing tray icons for providers you never use, which feels like spam even when nothing important changed. The Meta kernel family (the engine people mean when they say Mihomo or Clash Meta) exposes these concerns directly in YAML: proxy-providers and rule-providers are just structured HTTP jobs with timers. Learning interval and lazy is cheaper than chasing ghosts in rules: when the real issue is simply “this profile polls twelve URLs every five minutes for no reason.”
This article assumes you already import a valid profile. If you assemble configs by hand on Linux with systemd, the file layout in Linux Mihomo with systemd still applies; here we focus on the provider blocks inside the file the service loads. Mobile readers who mostly use a GUI can treat the snippets as “what the Export YAML button should contain after you understand the semantics.”
2 interval: automatic refresh cadence in YAML
For standard Clash-compatible schemas, each remote proxy-providers entry may include interval measured in seconds. A value of 3600 asks the core for roughly one background refresh per hour; 86400 is a calm daily rhythm for stable residential-style lists. Shorter windows—hundreds of seconds—are useful when an operator explicitly says nodes rotate quickly, but they are almost never “free,” because every pull is another TLS handshake and another line in someone else’s log. There is no universal best number: treat the panel’s documentation as the source of truth, then add margin so a transient failure does not cascade into a hammering retry loop from multiple devices you forgot were still online.
Some templates omit interval and rely on the client’s internal default. That is convenient until you open the same file on two different apps and see mismatched behavior. Making interval explicit in YAML removes that ambiguity and makes code review easy when a teammate asks why their laptop fan spikes every ten minutes. If your profile mixes several subscription URLs, set conservative intervals on experimental or backup providers and slightly faster ones only on the primary group you actively select.
interval handle the boring maintenance.
3 lazy: deferred first pull (“silent” behavior)
When lazy: true is set on a provider the grammar allows it on, the Meta stack can skip eager work at cold start. In plain language, the kernel avoids downloading a bulky subscription until a policy group that references that provider actually needs live data—often the moment you switch to a profile branch that contains those nodes. That pattern is what people colloquially call 静默拉取-style behavior in Chinese guides: fewer surprise downloads, fewer “updated!” toasts, and less chance that an idle backup link trips a useless network call while you are on cellular tethering.
lazy: false (or omitting the field, depending on how your template generator sets defaults) means the provider is eligible for immediate resolution during startup, which is what you want when the list must be present before the first user packet, for example on a headless gateway that boots unattended. Neither choice replaces interval; once the provider is active in memory, the periodic timer still applies. Think of lazy as controlling the first touch, not the whole maintenance story.
Be careful with oversized profiles: aggressive lazy plus a huge number of providers can defer work until the worst possible moment—right when you click a region selector during a live call. A balanced approach is to mark rarely used backup airports as lazy: true and keep the primary provider eager so your usual latency is predictable.
4 Concrete proxy-providers YAML you can paste
Below is a conservative illustration only: rename keys, adjust paths, and never publish real tokens. Headers such as User-Agent belong here when your panel requires them; the 403 guide explains that layer in depth. Notice how interval and lazy sit beside type: http and the url.
proxy-providers:
airport-main:
type: http
url: "https://example.com/subscribe?token=REPLACE_ME"
path: ./providers/airport-main.yaml
interval: 43200
lazy: false
header:
User-Agent: "Clash/1.0 (example; Mihomo-compatible)"
airport-backup:
type: http
url: "https://backup.example.net/clash?key=REPLACE_ME"
path: ./providers/airport-backup.yaml
interval: 86400
lazy: true
The path: line tells the core where to store the last successful download on disk. That file’s modification time is one of the quickest sanity checks when you suspect the timer never fired. If you version-control your config but ignore ./providers/, you avoid leaking live node lists into a Git repository while still keeping text history for the structural YAML.
interval with health-check.interval
Health checks re-probe already imported nodes for latency. They can be chatty in their own right. Keep both numbers intentional instead of stacking aggressive timers by accident.
5 rule-providers use the same vocabulary
Remote rule sets—Community lists, geosite mirrors, or operator-hosted snippets—also support interval and often benefit from the same discipline. Dragging in a dozen mega-lists and refreshing them every few minutes is one of the easiest ways to waste bandwidth while convincing yourself the proxy “feels slow.” Align rule pull frequency with how often those lists actually change: monthly static allowlists rarely deserve hourly polling. When you consolidate providers, you not only reduce noise; you also shrink the blast radius when one upstream publishes a bad release and you need to roll back.
If you operate a split repo where teammates mix third-party subscription URLs with internal policy, document the intended interval values in your README. Future you will not remember why geosite-google refreshes daily while airport-main refreshes twice per day unless the rationale is written down somewhere human-readable outside YAML comments.
6 Stacking timers: health checks, UI ticks, and backoff behavior
Real-world configs rarely stop at a single interval. URL-test or fallback groups may issue probes on their own cadence; some clients draw animated charts that imply constant activity even when upstream lists are static. Before you chase “phantom traffic,” list every moving part: provider HTTP downloads, rule ZIP pulls, DNS hooks, external-controller dashboards, and any cron helper you added beside the core. If totals still look high after trimming obvious duplicates, capture a short packet trace—often the culprit is an unrelated updater, not the Mihomo engine.
When an airport aggressively caches nodes, shortening interval does not magically invent fresher IP addresses; it only increases the probability that you see the same payload repeatedly. Conversely, if the operator rotates every hour and you set a week-long timer, diagnostic pages will look “stale” even though the YAML syntax is perfect. Match engineering to operations reality instead of cargo-cult numbers from old forum posts.
7 How to verify auto refresh actually runs
First, reload the profile cleanly after editing—each client exposes “reload” differently, but the goal is the same: the running process must parse the new interval and lazy values. Second, open the log buffer your app ships with and search for provider update lines; most builds print a recognizable message when an HTTP provider completes. Third, inspect the on-disk path: target: its size should grow after a successful fetch, and the filesystem timestamp should advance on the schedule you configured, modulo clock skew.
If you expose the external REST controller for debugging, some workflows let you query provider state directly; keep that port local-only or authenticated, as advised in external controller hardening notes. Whatever surface you use, the acceptance test is simple: after two multiples of interval, you should see evidence of at least one automatic refresh without clicking anything, unless lazy deferred work until you touched a selector—in which case watch for the first pull right after that interaction, followed by periodic updates afterward.
interval to a large value like 604800 (one week), reload, confirm no background pulls occur, then restore a sensible number. That confirms you are editing the file the live core actually reads—not an abandoned copy in Downloads.
8 What GUIs may rename or hide
Many desktop wrappers store subscription rows in a database and regenerate YAML on save. Toggle labels such as “Auto update” or “Update every … minutes” are thin wrappers around the same interval concept, sometimes converting minutes to seconds for you, sometimes not. If numbers look doubled or halved after export, diff the emitted file against your mental model before you blame the Meta stack. Likewise, switches that claim “only update when used” may map to lazy or to a client-only policy—export and grep for the literal token to know for sure.
Mobile clients vary widely: some expose granular per-URL timers, others collapse everything into a global setting. The portable skill remains reading exported YAML so you are never hostage to whichever tab got redesigned last month.
9 Frequently asked questions
Does a longer interval make connections safer?
It reduces how often you leak metadata about client activity to third-party hosts, which can marginally shrink an attack surface tied to telemetry-style logging—but it does not replace TLS hygiene, panel token rotation, or local firewall rules. Treat it as a courtesy, not a crypto feature.
Can I mix lazy with emergency override buttons?
Yes. Manual updates typically bypass waiting for the next tick; they exist precisely for “operator just posted a hotfix node list” moments. Your baseline interval can stay conservative while you keep override within one click.
What if my template does not support lazy?
Older converters occasionally strip unknown keys. Run a round-trip test: paste the field, save in the GUI, re-export. If the key vanishes, patch the generator or maintain a mixin layer that injects it after merge so the UI cannot drop it.
10 Wrap-up
Tuning interval and lazy is one of the few places where a ten-line YAML edit buys measurable quality-of-life: fewer pointless subscription requests, quieter clients, and behavior that matches how you actually use Mihomo rather than how a default template guessed you would. Pair this with the 403 checklist when fetches fail, and with mixin overrides when you want local annotations without fighting the updater.
Single-purpose CLI proxies and minimal forks often expose the same knobs only through opaque flags or require editing JSON that rebuilds on every launch; when the UI hides timer math entirely, you end up either under-fetching during outages or over-fetching until a provider silently throttles you. A maintained desktop client that surfaces logs, exports honest YAML, and aligns with the Clash Meta feature set makes this workflow boring in a good way. If you want that combination without stitching half a dozen tools together, the builds we curate on the download hub skew toward exactly this kind of transparent configuration. Once your timers feel right, spend your evening on routing policy—the part that actually changes how traffic leaves the machine.
