Merge Custom Proxies With Subscription YAML in Clash Meta: Mixin Steps That Work

Who this guide is for

The intended reader has a working import of provider YAML (or a converted Clash config) and wants two origins of nodes in the same runtime: commercial servers from HTTPS subscription, personal infrastructure from static definitions. You are not trying to replace Subconverter—if you only have a raw ss:// link and need a full playable profile first, start with the Subconverter to Clash YAML guide, then return here for coexistence. Likewise, if your primary pain is rules disappearing when subscriptions update, pair this article with the mixin rules overlay walkthrough; below we focus on the proxies inventory and the groups that reference it.

Why editing the downloaded subscription body fails

Most clients store subscription output in a cache file they are allowed to truncate on every refresh. When you open that file in an editor, append a vmess block under proxies:, fix spacing by hand, and save, you have created a local fork of a remote artifact. The updater’s contract is simple: download authoritative bytes from the provider, validate, write cache, reload the core. Your extra lines live in the same path the updater owns, so the next scheduled pull silently removes them. That behavior is not hostile—it keeps imports reproducible—but it means your VPS definitions belong in a different layer than the cached airport document.

Mental model: base profile plus overlay

Think in three moving parts. First, the base profile—whatever your client fetched from the airport URL, including their proxy-groups tree and rules. Second, your personal node material—either explicit proxies entries or a supplemental provider that yields proxies from disk or a tiny HTTPS payload. Third, optional routing glue: extra proxy-groups, selective rules, or references from existing group names. Mihomo merges mixin after the base document resolves, which is why the overlay survives refresh: the updater replaces the base snapshot while your mixin file remains a stable path on disk or a dedicated field in the GUI.

Pattern A — Manual proxies in mixin

The most direct pattern is to keep the airport import untouched and place VPS definitions in the mixin fragment your client merges on every load. Typical headless layouts reference mixin.yaml beside the primary config; GUI forks expose the same structure as “Merge,” “Patch,” or “Profile extension.” Under mixin, declare additional proxies list items with unique name values that cannot collide with provider-generated labels. Mihomo generally appends mixin list entries to the combined proxy table, but implementation details can shift—verify once after upgrade.

Safe group strategy. Instead of redefining the airport’s flagship proxy-groups entry (which risks replacing their entire member list depending on merge semantics), add a new group such as MY-VPS containing only your nodes, then optionally add a relay or select wrapper that also lists one of their auto groups if you want a unified chooser. Referencing your new group from a small number of high-priority rules rows—added in mixin per the rules-focused guide—keeps blast radius small when the airport renames emoji-decorated groups.

# mixin.yaml — illustrative; adjust names, types, and server fields
proxies:
  - name: "VPS-SINGAPORE-SS"
    type: ss
    server: 203.0.113.50
    port: 8388
    cipher: aes-256-gcm
    password: "REPLACE_ME"

proxy-groups:
  - name: "MY-VPS"
    type: select
    proxies:
      - "VPS-SINGAPORE-SS"

Once MY-VPS appears in the merged profile, bind domains or IP rules to it explicitly—for example office SaaS that must egress from your static IP—while leaving bulk GEOIP handling to the provider’s existing MATCH chain.

Pattern B — Dual proxy-providers (airport + local file)

Pattern B shines when you want both feeds to behave like imported inventories with explicit refresh cadence. Point one proxy-providers entry at the same HTTPS URL your airport already publishes, targeting a cache path under the client’s working directory. Add a second provider with type: file or type: http whose body is a minimal YAML that only lists your personal proxies. Mihomo expands providers into concrete proxy objects at load time; your GUI usually shows the union in selection lists. This mirrors how power users compose multiple airlines without hand-merging thousands of lines.

When using type: file, keep the satellite file under version control and validate indentation whenever you edit on a phone or through a rich-text box that may mangle spaces. Use the same two-space convention as the rest of the Clash ecosystem; tabs are a common reason parsers reject otherwise valid snippets.

# Fragment inside main profile or mixin — illustrative
proxy-providers:
  airport:
    type: http
    url: "https://example.com/subscription-token"
    path: ./providers/airport.yaml
    interval: 3600
    health-check:
      enable: true
      url: https://www.gstatic.com/generate_204
      interval: 600

  home-lab:
    type: file
    path: ./providers/home-lab.yaml
    health-check:
      enable: true
      url: https://www.gstatic.com/generate_204
      interval: 600

proxy-groups:
  - name: "COMBINED-HANDOFF"
    type: select
    use:
      - airport
      - home-lab

The use: field pulls every proxy each provider emits into the group; rename or filter using client-specific features if offered. For automated health-based selection, translate the pattern in the url-test and fallback tutorial once both inventories load.

YAML hygiene: indentation, duplicates, and anchors

Clash configurations are rich YAML trees; the mistakes that generate “it was working until I pasted once” are predictable. Maintain consistent indentation so nested maps stay aligned—misplacing a - name: line by one level attaches it to the wrong parent map and yields errors that reference the wrong line number. Avoid YAML merge keys and heavy anchor aliases in beginner setups; they compress nicely in repositories but confuse GUI editors and invalidate mental models when three teammates edit different layers.

Duplicate name fields are the silent killer. Subscription converters may prefix nodes with provider tags; manual entries rarely do. If your VPS ends up labeled HK-01 and the airport publishes the same string, the later definition wins or the core rejects the load depending on version. Prefix personal assets (VPS-HK-01) and grep the merged profile whenever you add nodes.

Step-by-step checklist

Merge semantics at a glance

Artifact	Typical behavior on subscription refresh	What to verify
Cached airport YAML	Redownloaded; node names may reorder	Downstream rules still reference real group names
mixin proxies	Usually merged in after base load; not part of remote cache	Every manual name is unique in the effective profile
proxy-providers file feed	Reloaded from disk path you control	path resolves and health checks succeed
proxy-groups in mixin	New groups append; overlapping keys may follow last-writer rules	Avoid duplicating provider group names unless tested

Verification after refresh

Run the same validation after client upgrades as after your own edits. Capture three artifacts: the provider’s raw download (optional), your mixin or provider sidecar on disk, and the merged runtime view. If the runtime view loses your nodes while the sidecar file is untouched, the client is not applying mixin—double-check profile paths and GUI toggles before chasing DNS or TUN problems.

1. Before refresh: export proxies and groups; note the count of personal entries.
2. Refresh: use the explicit subscription update control, not just a core restart.
3. After refresh: counts should match; provider-only fields move while personal names remain.
4. Functional pass: switch to your VPS group in the UI and load an IP echo service that reflects the exit you expect.

Pitfalls that masquerade as broken proxies

• Stale group references: provider renames selection groups; your mixin still targets obsolete strings.
• Health check starvation: dual providers with aggressive intervals may rate-limit; widen intervals temporarily to test.
• Permission paths: sandboxed macOS clients cannot read arbitrary filesystem paths—place sidecar YAML inside the profile directory the app already owns.
• TUN vs system proxy: personal rules may work under one mode and bypass the stack under another; align with baseline Windows or Verge macOS guidance before debugging node health.

FAQ

Can I stay on a single subscription URL and never touch Subconverter?

Yes. Pattern A (mixin proxies) keeps the HTTPS import intact while you layer manual assets. Subconverter becomes optional the moment you need cleaner separation of provider rules from your own tree.

The airport renamed every node after an update

Expect that from dynamic lists. Track stable identifiers only for assets you control; for everything else, anchor rules to proxy-groups the provider maintains or to domain-based logic, not brittle per-node names.

Does every protocol work in mixin?

Supported protocols depend on the exact Mihomo build and platform. Validate with a minimal config, then expand; unsupported fields fail fast during load rather than at runtime.

Maintenance habits

Put multi-source nodes on autopilot

Once manual definitions live outside the volatile subscription cache, Clash Meta stops fighting your workflow: commercial inventories refresh automatically, your VPS stays wired into purpose-built groups, and YAML edits become reviewable diffs instead of fragile pastes.

Download Clash for free and experience the difference