How Clash Verge Rev Media Unlock Checking Works for Netflix and Streaming Services

Clash Verge Rev performs media unlock detection through a Rust-based Tauri backend that executes parallel HTTP probes to streaming endpoints, analyzing response status codes and redirect headers to determine regional availability.

Clash Verge Rev is a popular GUI client for Clash that includes built-in functionality to verify whether specific streaming services like Netflix, Disney+, and others are accessible through configured proxy nodes. Understanding how Clash Verge Rev media unlock checking operates helps users troubleshoot connectivity issues and verify regional content availability. The implementation resides in the Tauri backend, specifically within the src-tauri/src/cmd/media_unlock_checker/ directory, utilizing asynchronous Rust with reqwest and tokio for concurrent service validation.

Architecture of the Media Unlock Checker

The media unlock system follows a modular async architecture designed for efficiency and extensibility.

Core Components

The checker is orchestrated through src-tauri/src/cmd/media_unlock_checker/mod.rs, which defines the check_media_unlock Tauri command. This command initializes a reqwest::Client configured with a realistic Chrome user-agent, TLS support, generous timeouts, and relaxed certificate validation to handle various proxy configurations.

Parallel Execution Strategy

Rather than checking services sequentially, the implementation uses tokio::task::JoinSet to spawn concurrent async tasks. Each media service implements a dedicated check_<service> function (e.g., check_netflix), receiving a shared Arc<reqwest::Client> to minimize connection overhead. Results are collected into a thread-safe Arc<Mutex<Vec<UnlockItem>>> before being returned to the frontend.

Netflix Unlock Detection Logic

The Netflix verification algorithm, implemented in src-tauri/src/cmd/media_unlock_checker/netflix.rs, employs a multi-phase probing strategy to determine both availability and regional catalog access.

Phase 1: CDN API Verification

The checker first queries https://api.fast.com/netflix/speedtest/v2 to quickly determine if the IP is already flagged as blocked. If the API returns HTTP 403 or indicates a blocked status, the check returns "No" immediately. A positive response allows early termination with "Yes" status.

Phase 2: Title Probes and Status Code Analysis

If the CDN test is inconclusive, the system performs HTTP GET requests to two specific Netflix title URLs:

• https://www.netflix.com/title/81280792
• https://www.netflix.com/title/70143836

The HTTP status codes determine the unlock status:

• 404 on both: Returns "Originals Only", indicating the IP can access only Netflix Originals content.
• 403 on either: Returns "No", signaling the IP is banned or blocked.
• 200 or 301: Proceeds to regional detection.

Phase 3: Regional Detection via Redirect

When content is accessible, the checker fetches a third test URL (https://www.netflix.com/title/80018499) and examines the Location header in the response. The redirect URL contains a region suffix (e.g., /title/80018499-us). The parser extracts this ISO-3166 country code, validates it, and converts it to a flag emoji using country_code_to_emoji from utils.rs. If parsing fails, it defaults to "US".

Data Model and Utilities

The unlock status is standardized through the UnlockItem struct defined in src-tauri/src/cmd/media_unlock_checker/types.rs:

pub struct UnlockItem {
    pub name: String,           // Service name, e.g., "Netflix"
    pub status: String,       // "Yes", "No", "Originals Only", "Failed ..."
    pub region: Option<String>, // Flag emoji + code, e.g., "🇺🇸us"
    pub check_time: Option<String>,
}

Supporting utilities in src-tauri/src/cmd/media_unlock_checker/utils.rs provide:

• get_local_date_string(): Generates ISO-formatted timestamps for the check_time field.
• country_code_to_emoji(): Converts two-letter country codes to Unicode flag emojis by mapping regional indicator symbols.

Frontend Integration

The Tauri backend exposes two primary commands that the JavaScript/TypeScript frontend invokes:

import { invoke } from '@tauri-apps/api/tauri';

// Retrieve initial pending state
const pendingList = await invoke('get_unlock_items');

// Execute full unlock check
const results = await invoke('check_media_unlock');
// Returns: [{ name: "Netflix", status: "Yes", region: "🇺🇸us", check_time: "2024-01-15T10:30:00" }, ...]

The check_media_unlock command in src-tauri/src/cmd/media_unlock_checker/mod.rs orchestrates the entire flow, returning the aggregated Vec<UnlockItem> to the UI for display.

Summary

• Clash Verge Rev performs media unlock detection through a Rust-based Tauri backend using asynchronous HTTP probes.
• The Netflix checker implements a three-phase algorithm: CDN API verification, dual title probe analysis, and redirect-based region extraction.
• Parallel execution via tokio::task::JoinSet ensures efficient checking of multiple streaming services simultaneously.
• Results are standardized in the UnlockItem struct with ISO timestamps and Unicode flag emojis for regional identification.
• The frontend invokes check_media_unlock via Tauri commands to retrieve real-time unlock status for proxy nodes.

Frequently Asked Questions

How accurate is Clash Verge Rev's Netflix region detection?

The region detection relies on Netflix's actual redirect behavior for geo-restricted content URLs. When the checker receives a 301/302 redirect to a region-specific URL (e.g., /title/80018499-us), it extracts the ISO-3166 country code from the Location header. This method accurately reflects the catalog Netflix would serve to that IP address, though occasional CDN anomalies or network interruptions may cause fallback to "US" or "Failed" states.

Why does the checker show "Originals Only" for some nodes?

The "Originals Only" status indicates that the IP address can access Netflix's self-produced content but not licensed third-party content. This occurs when both test title URLs return HTTP 404, suggesting the IP is recognized as belonging to a VPN or proxy range that Netflix restricts to original content only. This is distinct from a complete ban (403 status), which would return "No".

Can I extend the media unlock checker to support additional streaming services?

Yes, the modular architecture in src-tauri/src/cmd/media_unlock_checker/ supports extension. You would create a new file (e.g., hbo.rs) implementing an async check_hbo function that accepts &reqwest::Client and returns an UnlockItem. Add the service name to the default list in types.rs, then spawn the new check in the JoinSet within mod.rs. The frontend will automatically display the new service in the unlock status panel.

What happens if a network timeout occurs during the check?

The reqwest::Client is configured with generous timeouts (typically 30 seconds) in mod.rs. If a timeout or network error occurs during any phase of the Netflix check (CDN API, title probes, or region detection), the function catches the error and returns an UnlockItem with status set to "Failed" followed by the error message (e.g., "Failed: request timeout"). This ensures the UI receives a definitive result rather than hanging indefinitely.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}