Set Clash Verge Rev subscription refresh: align the GUI and Mihomo Profile YAML

Why subscription refresh is a two-layer problem

Think of Clash Verge Rev as the cockpit and Mihomo as the engine. The cockpit lets you import a remote subscription, label it, and pick how aggressively you want fresh nodes. The engine reads a compiled Profile where outbound inventories are usually modeled as proxy-providers. Those blocks carry their own timing fields. If someone edits YAML by hand, restores an old backup, or mixes merge rules, the number you typed in the UI may no longer match what the daemon parses.

Misaligned intervals do not always surface as a dramatic error. People notice staleness instead: nodes vanish from provider dashboards while the client still shows yesterday’s list, latency tests climb because half the exits were rotated, or “it worked until the airline pushed maintenance”. Treating subscription auto update as a contract between the GUI, on-disk YAML, and the running core prevents those quiet failures. The workflow below is deliberately boring and explicit because that is what debugging calendars prefers.

Quick vocabulary before you touch settings

• Profile: the active configuration document Verge hands to mihomo—rules, groups, DNS, and provider hooks in one place.
• proxy-providers: YAML map entries that download or read proxy lists on a schedule and expose them to policy groups through use: statements.
• interval: In provider maps, usually seconds between fetches for HTTP-style providers. Some docs and forum posts say update-interval conversationally; in the file the field name is typically interval on the provider itself.
• Manual update: A user-triggered pull that should happen immediately, independent of the timer.

Step 1 — Set subscription refresh in Clash Verge Rev (Windows and macOS)

The exact layout shifts slightly between releases, but the control you need is stable: open the Profiles area, locate the subscription card that backs your current Profile, and edit its metadata. On Windows you will usually right-click or open an overflow menu on the card. On macOS the same entry appears as a three-dot or pencil icon pattern familiar to Verge users. Choose Edit (sometimes labeled alongside download controls) and find the field named Update Interval or equivalent wording.

The UI almost always asks for hours. Pick a value that matches how volatile your provider is. A daily refresh (24) remains the conservative default for many residential users. If your vendor publishes maintenance windows hourly, tightening to 6 or even 1 reduces the window where dead exits linger—at the cost of more frequent network pulls. Enterprise customers on capped networks sometimes widen the window; travelers who tether may temporarily shorten it while hopping airports. None of these choices are morally superior; they are risk trade-offs.

After you commit the field, perform three sanity checks before leaving the screen. First, confirm the item is still the active Profile; inactive cards download but do not drive traffic. Second, trigger a manual update once to ensure the endpoint returns YAML rather than an HTML login page—token rotation is a separate issue but must be ruled out. Third, look at the proxy list counters: zero nodes after a “successful” save still means you are not ready to talk timers.

Step 2 — Inspect the Mihomo Profile your core actually runs

Now you move from UX chrome to the document layer. Open the in-app YAML viewer if your build offers it, or export the active Profile to a text editor you trust. The goal is not aesthetic formatting; it is to locate the proxy-providers stanza that corresponds to the same subscription URL you just edited. Large airline-generated files may include multiple providers—home-brew merge setups add even more—so match on the url: field or a distinctive comment before matching intervals.

A minimal illustrative fragment might look like this (values are fictional; indentation follows common two-space norms):

proxy-providers:
  airline-main:
    type: http
    url: "https://example.com/subscribe?token=demo"
    path: ./providers/airline-main.yaml
    interval: 86400

The interval line is the heartbeat you are auditing. Some profiles wrap providers inside generator tooling; others import patches through proxy-providers plus external rule-providers. If you maintain mixed setups, scan each HTTP-type provider separately—stale rules and stale nodes produce different symptoms, but both punish assumptions. When you also use local type: file providers, those entries may omit a network interval because disk polling behaves differently; focus on HTTP providers tied to subscription URLs first.

On Windows, absolute paths differ but the relative layout is the same: the Profile is recreated whenever Verge recompiles inputs. On macOS, sandboxing and permission prompts can delay writes; if you edit externally, ensure the app is not mid-sync. The safest pattern is read-only inspection inside Verge, then deliberate saves rather than hot-patching files the GUI still owns.

Step 3 — Align hours in the GUI with seconds in proxy-providers

Multiply the hours you chose in step one by 3600. Compare that product with each relevant interval: under proxy-providers. Equality is the success criterion. If the YAML still shows a legacy value—perhaps 3600 from an old experiment while the UI reads twelve hours—your effective refresh remains the smaller number no matter what the card claims. Fix by re-saving from the GUI, removing conflicting overrides, or editing deliberately if you have taken ownership of the file.

Table lookups help teams standardize without reaching for calculators mid-incident:

• 1 hour → 3600 seconds
• 6 hours → 21600 seconds
• 12 hours → 43200 seconds
• 24 hours → 86400 seconds
• 48 hours → 172800 seconds

When numbers almost match but not quite—say 82800 instead of 86400—treat that as a signal that another automation layer touched the profile. Search for mixin files, scheduled scripts, or provider-side defaults. Some dashboards inject their own recommended interval when users re-import. The debugging recipe is unchanged: identify the last writer, reconcile intentions, then reload the core so mihomo picks up the final YAML.

rule-providers: when “update interval” means something else

Search forums blur terminology. Rule-providers also use interval fields to refresh remote rule sets. Those timers do not replace subscription timers; they complement them. If you chase a node issue but only tune rule-provider cadence, proxies still go stale, and vice versa. When aligning policy, open both sections in the Profile, list each remote URL, and note paired intervals. Teams that split ownership—one teammate curates rules while another manages exits—should document which half owns which clock.

Manual refresh versus periodic refresh

Manual updates are invaluable after provider maintenance or when you rotate tokens. They do not cancel the periodic schedule; they add an immediate fetch. If a manual pull succeeds but scheduled pulls fail, suspect clock skew, DNS interception, or TLS middleboxes on certain networks—symptoms show up as intermittent i/o timeout lines rather than parser errors. Conversely, if manual pulls fail instantly, fix credentials before obsessing over intervals.

Multiple profiles and testing duplicates

Power users keep experimental Profiles alongside production. Each file may duplicate proxy-providers names or URLs. When you verify intervals, do it against the active profile only, then repeat for side projects as needed. Mixing up files is a classic way to “fix” YAML that was never loaded. Verge usually makes the selected row obvious; if not, follow traffic tests—connections should map to proxies present in the file you edited.

How this differs from Android-only interval guides

Our Android documentation focuses on background constraints, vendor battery policies, and mobile-specific schedulers. Desktop Windows and macOS stacks rarely die for the same reasons, but they introduce others: sleep states, lid-close behaviors on notebooks, and multiple GUIs fighting for the same ports. The shared lesson is still to confirm the engine’s view of timers—not only the animation in a client. If you also manage phones, read the Android subscription interval article for complementary background context.

Where to go next in the Verge Rev series

If you are still building a first desktop install, pair this timer work with the platform primers: Windows 11 install and macOS setup cover permissions, kernel choice, and activation order that must succeed before refresh politics matter. For day-two policy questions—mixed proxies, subscription plus local nodes—open profiles, subscriptions, and proxy modes to keep routing coherent while timers tick.

Frequently asked questions

Why do I see hours in Verge but seconds in YAML?

Graphical clients optimize for human increments. The mihomo parser historically thinks in seconds for fetch cadence because it aligns with internal timers and cross-platform parity. The conversion is deterministic; mismatches imply stale files or alternate writers, not mystery math.

Is a shorter interval always safer?

Shorter pulls reduce staleness but increase fingerprinting surface and bandwidth use. Some providers rate-limit aggressive clients. Pick the shortest interval your vendor tolerates and your connectivity budget allows—not the smallest number the input box accepts.

I changed the GUI but YAML stayed the same—why?

Common causes include editing a non-active profile, a failed save due to permissions, a mixin overriding providers, or an external editor rewinding the file. Confirm the active row, re-save, and search for duplicate provider keys. When in doubt, export a fresh profile snapshot after a restart.

Summary

Many community clients look polished yet hide the YAML layer until something breaks—then you are left guessing whether stale nodes came from schedules, DNS, or silent profile swaps. A workflow that treats subscription refresh, proxy-providers, and transparent Profile inspection as one system keeps surprises rare.

Clash emphasizes that transparency: readable defaults, documented fields, and fewer black-box merges between what you click and what runs. If you care about knowing the exact update interval your core honors—not just a pretty toggle—keeping the GUI and Mihomo YAML in lockstep is the cheapest insurance policy.

When you want a client ecosystem that stays predictable across Windows, macOS, and other platforms, start from a maintained build and verify configurations the way operators do—by reading the running file. If that approach matches how you like to work, download Clash and try the same alignment checklist against your own provider.