How to Set Up Auto-Update for Clash Subscriptions: Always Have Fresh Nodes

Understanding the Mechanics of Auto-Updates

Proxy nodes are not static. Providers frequently rotate IP addresses, migrate servers, or adjust bandwidth limits to bypass censorship and manage costs. If you rely on a static configuration file, your connection will eventually drop, leaving you scrambling to manually download and import a new subscription.

The clash auto update subscription mechanism solves this by periodically fetching the latest configuration from your provider's remote server. Instead of hardcoding nodes into your local config.yaml, the client maintains a reference to the remote URL. At specified intervals, it downloads the raw payload, parses the nodes, and seamlessly merges them with your local routing rules and preferences.

When Mihomo fetches an update, it reads the store-selected: true parameter in your configuration. This crucial setting tells the core to remember your active proxy selection across restarts and updates. Without it, every auto-update would reset your active node to the default, disrupting your workflow.

Prerequisites for Seamless Updates

Before configuring automated refreshes, you must ensure your foundation is solid. A broken initial setup will only compound errors when automation is introduced.

Configuring Auto-Update in Clash Verge Rev

Clash Verge Rev is currently the most popular desktop client for Mihomo. It features a robust profile management system that handles auto-updates elegantly.

Setting Up Auto-Update on Clash Meta for Android

Mobile users face frequent network environment changes. Keeping nodes fresh on Android is critical for battery life and connection stability.

Advanced: Headless Linux Automation via Cron

For users running Mihomo on a headless Linux server, router, or NAS without a GUI, the core application does not natively poll remote subscriptions. You must build an external automation pipeline.

This approach involves using a shell script to download the subscription, convert it if necessary, and trigger a Mihomo API reload.

#!/bin/bash
# /opt/clash/update-sub.sh

SUB_URL="https://provider.com/api/v1/sub?token=xyz"
CONFIG_DIR="/etc/mihomo"
TEMP_FILE="/tmp/sub-raw.yaml"

# Download the raw subscription
curl -sL "$SUB_URL" -o "$TEMP_FILE"

# If your provider outputs Base64, decode it first
# base64 -d "$TEMP_FILE" > "$CONFIG_DIR/config.yaml"

# If it is already YAML, move it directly
mv "$TEMP_FILE" "$CONFIG_DIR/config.yaml"

# Reload Mihomo via RESTful API
curl -s -X PUT http://127.0.0.1:9090/configs \
  -H "Content-Type: application/json" \
  -d '{"path": "/etc/mihomo/config.yaml"}'

Merging Local Configurations

Downloading the raw subscription overwrites your local DNS and routing tweaks. To solve this, use yq to merge the downloaded subscription with a local base configuration.

# Install yq
wget https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 -O /usr/bin/yq
chmod +x /usr/bin/yq

# Merge base config with remote subscription
yq eval-all 'select(fileIndex == 0) * select(fileIndex == 1)' \
  /etc/mihomo/base.yaml /tmp/sub-raw.yaml > /etc/mihomo/config.yaml

0 */6 * * * /bin/bash /opt/clash/update-sub.sh >> /var/log/clash-update.log 2>&1

Troubleshooting Auto-Update Failures

Even with automation configured, updates can fail silently or throw errors. Understanding the common failure points is essential for maintaining a reliable proxy environment.

HTTP 403 Forbidden or Network Timeouts

If the client cannot reach the subscription server, it will keep using the cached nodes. This often happens if the subscription domain is blocked by your local ISP or if the provider requires a specific User-Agent.

YAML Parsing Errors After Update

If the provider changes their configuration structure (e.g., migrating from legacy Clash to Mihomo syntax), the auto-update might download a file that breaks your client. Always ensure your core version matches the subscription format requirements. Check the Mihomo release notes for any breaking changes in YAML schema.

Best Practices for Subscription Management

Setting up the clash auto update subscription is only the first step. Managing how those updates interact with your local environment ensures long-term stability.

• Separate Nodes from Rules: Never hardcode proxy nodes directly into your main rules. Always use proxy-groups to reference the subscription payload. This allows the nodes to update without breaking your routing logic.
• Use Filtering Scripts: Subscriptions often contain dozens of dead or slow nodes. Use client-side filtering (like the use filter in Clash Verge Rev) to automatically exclude nodes matching specific keywords, such as "Expire" or "Bandwidth Exceeded".
• Maintain a Fallback Profile: Keep a secondary, static subscription link from a different provider in your client. If your primary provider experiences an outage or their subscription API goes down, you can instantly switch to the fallback profile without losing connectivity.

Many advanced users maintain multiple subscriptions to balance cost and performance. For example, you might use a premium subscription for streaming and a budget one for general browsing. In Clash Verge Rev, you can chain multiple remote profiles. The client will merge the node lists, allowing you to create complex proxy-groups that route traffic based on the combined node pool.