user-scanner 1.0.0.0__tar.gz

user_scanner-1.0.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kaif
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

user_scanner-1.0.0.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: user-scanner
+Version: 1.0.0.0
+Summary: Check username availability across multiple popular platforms
+Keywords: username,checker,availability,social,tech,python,user-scanner
+Author-email: Kaif <kafcodec@gmail.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx
+Requires-Dist: colorama
+Project-URL: Homepage, https://github.com/kaifcodec/user-scanner
+
+# user-scanner

user_scanner-1.0.0.0/README.md

@@ -0,0 +1 @@
+# user-scanner

user_scanner-1.0.0.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["flit_core >=3.2,<4"]
+build-backend = "flit_core.buildapi"
+
+[project]
+name = "user-scanner"
+version = "1.0.0.0"
+description = "Check username availability across multiple popular platforms"
+readme = "README.md"
+license = {file = "LICENSE"}
+authors = [
+  {name = "Kaif", email = "kafcodec@gmail.com"}
+]
+dependencies = [
+  "httpx",
+  "colorama"
+]
+
+requires-python = ">=3.7"
+keywords = ["username", "checker", "availability", "social", "tech", "python", "user-scanner"]
+
+[project.urls]
+Homepage = "https://github.com/kaifcodec/user-scanner"
+
+[project.scripts]
+user-scanner = "user_scanner.__main__:main"

user_scanner-1.0.0.0/user_scanner/__main__.py

@@ -0,0 +1,18 @@
+import argparse
+from user_scanner.core.orchestrator import run_checks
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="user-scanner",
+        description="Scan a username across dev, social, creator, and community platforms."
+    )
+    parser.add_argument(
+        "-u", "--username",
+        required=True,
+        help="Username to scan across all supported platforms."
+    )
+    args = parser.parse_args()
+    run_checks(args.username)
+
+if __name__ == "__main__":
+    main()

user_scanner-1.0.0.0/user_scanner/core/orchestrator.py

@@ -0,0 +1,62 @@
+import importlib
+import pkgutil
+from colorama import Fore, Style
+
+def load_modules(package):
+
+    modules = []
+    for _, name, _ in pkgutil.iter_modules(package.__path__, package.__name__ + "."):
+        try:
+            module = importlib.import_module(name)
+            modules.append(module)
+        except Exception as e:
+            print(f"Failed to import {name}: {e}")
+    return modules
+
+
+def run_checks(username):
+
+    from user_scanner import dev, social,creator, community
+
+    categories = [
+        ("DEV", dev),
+        ("SOCIAL", social),
+        ("CREATOR", creator),
+        ("COMMUNITY", community)
+    ]
+
+    print(f"\n{Fore.CYAN} Checking username: {username}{Style.RESET_ALL}\n")
+
+    for cat_name, package in categories:
+        try:
+            modules = load_modules(package)
+        except ModuleNotFoundError:
+            continue
+
+        print(f"{Fore.MAGENTA}== {cat_name} SITES =={Style.RESET_ALL}")
+
+        for module in modules:
+            # Find the first function starting with "validate_"
+            func = None
+            for f in dir(module):
+                if f.startswith("validate_") and callable(getattr(module, f)):
+                    func = getattr(module, f)
+                    break
+            if not func:
+                continue
+
+            site_name = module.__name__.split('.')[-1].capitalize()
+            if site_name == "X":
+               site_name = "X (Twitter)"
+            try:
+                result = func(username)
+                if result == 1:
+                    print(f"  {Fore.GREEN}[✔] {site_name}: Available{Style.RESET_ALL}")
+                elif result == 0:
+                    print(f"  {Fore.RED}[✘] {site_name}: Taken{Style.RESET_ALL}")
+                else:
+                    print(f"  {Fore.YELLOW}[!] {site_name}: Error{Style.RESET_ALL}")
+            except Exception as e:
+                print(f"  {Fore.YELLOW}[!] {site_name}: Exception - {e}{Style.RESET_ALL}")
+
+        print()

user_scanner-1.0.0.0/user_scanner/creator/devto.py

@@ -0,0 +1,37 @@
+import httpx
+from httpx import ConnectError, TimeoutException
+
+def validate_devto(user):
+    url = f"https://dev.to/{user}"
+
+    headers = {
+        'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
+        'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+    }
+
+    try:
+        response = httpx.head(url, headers=headers, timeout=3.0, follow_redirects=True)
+        status = response.status_code
+
+        if status == 200:
+           return 0
+        elif status == 404:
+           return 1
+        else:
+           return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   user = input ("Username?: ").strip()
+   result = validate_devto(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occurred!")

user_scanner-1.0.0.0/user_scanner/creator/hashnode.py

@@ -0,0 +1,54 @@
+import httpx
+import json
+from httpx import ConnectError, TimeoutException
+
+def validate_hashnode(user):
+    url = "https://hashnode.com/utility/ajax/check-username"
+
+    payload = {
+      "username": user,
+      "name": "Dummy Dummy"
+    }
+
+    headers = {
+      'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Mobile Safari/537.36",
+      'Accept': "application/json",
+      'Content-Type': "application/json",
+      'Origin': "https://hashnode.com",
+      'Referer': "https://hashnode.com/signup",
+    }
+
+    try:
+        response = httpx.post(url, json=payload, headers=headers, timeout=3.0)
+
+        if response.status_code == 200:
+            data = response.json()
+
+            if 'status' in data:
+                if data['status'] == 1:
+                    return 1
+                elif data['status'] == 0:
+                    return 0
+
+            return 2
+
+        else:
+           return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except json.JSONDecodeError:
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   user = input ("Username?: ").strip()
+   result = validate_hashnode(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occurred!")

user_scanner-1.0.0.0/user_scanner/creator/kaggle.py

@@ -0,0 +1,41 @@
+import httpx
+from httpx import ConnectError, TimeoutException
+
+def validate_kaggle(user):
+    url = f"https://www.kaggle.com/{user}"
+
+    headers = {
+        'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Mobile Safari/537.36",
+        'Accept': "text/html",
+    }
+
+    try:
+        # Use GET request for maximum fidelity, though we only check status code
+        response = httpx.get(url, headers=headers, timeout=3.0, follow_redirects=True)
+        status = response.status_code
+
+        # If a profile exists (Taken) -> 200 OK
+        if status == 200:
+           return 0
+        # If no profile exists (Available) -> 404 Not Found
+        elif status == 404:
+           return 1
+        # Other status codes are errors
+        else:
+           return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   user = input ("Username?: ").strip()
+   result = validate_kaggle(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occurred!")

user_scanner-1.0.0.0/user_scanner/creator/medium.py

@@ -0,0 +1,41 @@
+import httpx
+from httpx import ConnectError, TimeoutException
+
+def validate_medium(user):
+    url = f"https://medium.com/@{user}"
+
+    headers = {
+        'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
+        'Accept': "text/html",
+    }
+
+    try:
+        response = httpx.get(url, headers=headers, timeout=3.0)
+
+        if response.status_code == 200:
+            html_text = response.text
+
+
+            username_tag = f'property="profile:username" content="{user}"'
+
+            if username_tag in html_text:
+                return 0
+            else:
+                return 1
+        return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   user = input ("Username?: ").strip()
+   result = validate_medium(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occurred!")

user_scanner-1.0.0.0/user_scanner/dev/__init__.py

@@ -0,0 +1 @@
+# tech

user_scanner-1.0.0.0/user_scanner/dev/codeberg.py

@@ -0,0 +1,37 @@
+import httpx
+from httpx import ConnectError, TimeoutException
+
+def validate_codeberg(user):
+    url = f"https://codeberg.org/{user}"
+
+    headers = {
+        'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Mobile Safari/537.36",
+        'Accept': "text/html",
+    }
+
+    try:
+        response = httpx.head(url, headers=headers, timeout=3.0, follow_redirects=True)
+        status = response.status_code
+
+        if status == 200:
+           return 0
+        elif status == 404:
+           return 1
+        else:
+           return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   user = input ("Username?: ").strip()
+   result = validate_codeberg(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occurred!")

user_scanner-1.0.0.0/user_scanner/dev/cratesio.py

@@ -0,0 +1,39 @@
+import httpx
+from httpx import ConnectError, TimeoutException
+
+def validate_cratesio(user):
+    url = f"https://crates.io/api/v1/users/{user}"
+
+    headers = {
+        'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Mobile Safari/537.36",
+        'Accept': "application/json",
+        'Referer': "https://crates.io/",
+        'sec-fetch-mode': "cors",
+    }
+
+    try:
+        response = httpx.head(url, headers=headers, timeout=5.0)
+        status = response.status_code
+
+        if status == 200:
+           return 0
+        elif status == 404:
+           return 1
+        else:
+           return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   user = input ("Username?: ").strip()
+   result = validate_cratesio(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occurred!")

user_scanner-1.0.0.0/user_scanner/dev/dockerhub.py

@@ -0,0 +1,40 @@
+import httpx
+from httpx import ConnectError, TimeoutException
+
+def validate_dockerhub(user):
+    url = f"https://hub.docker.com/v2/users/{user}/"
+
+    headers = {
+        'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
+        'Accept': "application/json",
+    }
+
+    try:
+        response = httpx.get(url, headers=headers, timeout=3.0)
+        status = response.status_code
+
+        # UNAVAILABLE (return 0) if the user API endpoint returns 200 OK
+        if status == 200:
+           return 0
+        # AVAILABLE (return 1) if the user API endpoint returns 404 Not Found
+        elif status == 404:
+           return 1
+        # Other status codes are errors
+        else:
+           return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   user = input ("Username?: ").strip()
+   result = validate_dockerhub(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occurred!")

user_scanner-1.0.0.0/user_scanner/dev/github.py

@@ -0,0 +1,46 @@
+import httpx
+from httpx import ConnectError, TimeoutException
+
+def validate_github(user):
+    url = f"https://github.com/signup_check/username?value={user}"
+
+    headers = {
+          'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36",
+          'Accept-Encoding': "gzip, deflate, br, zstd",
+          'sec-ch-ua-platform': "\"Linux\"",
+          'sec-ch-ua': "\"Chromium\";v=\"140\", \"Not=A?Brand\";v=\"24\", \"Google Chrome\";v=\"140\"",
+          'sec-ch-ua-mobile': "?0",
+          'sec-fetch-site': "same-origin",
+          'sec-fetch-mode': "cors",
+          'sec-fetch-dest': "empty",
+          'referer': "https://github.com/signup?source=form-home-signup&user_email=",
+          'accept-language': "en-US,en;q=0.9",
+          'priority': "u=1, i"
+}
+
+    try:
+        response = httpx.get(url, headers=headers, timeout = 3.0)
+        status = response.status_code
+
+        if status == 200:
+           return 1
+        elif status == 422:
+           return 0
+        else:
+           return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   user = input ("Username?: ").strip()
+   result = validate_github(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occured!")

user_scanner-1.0.0.0/user_scanner/dev/gitlab.py

@@ -0,0 +1,51 @@
+import httpx
+import json
+from httpx import ConnectError, TimeoutException
+
+def validate_gitlab(user):
+    url = f"https://gitlab.com/users/{user}/exists"
+
+    headers = {
+          'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
+          'Accept': "application/json, text/plain, */*",
+          'X-Requested-With': "XMLHttpRequest",
+          'Referer': "https://gitlab.com/users/sign_up",
+    }
+
+    try:
+        response = httpx.get(url, headers=headers, timeout=3.0)
+
+        if response.status_code == 200:
+            data = response.json()
+
+            if 'exists' in data:
+                # Corrected: Compare against Python boolean True/False
+                # AVAILABLE (return 1) if "exists": true
+                if data['exists'] is False:
+                    return 1
+                # UNAVAILABLE (return 0) if "exists": false
+                elif data['exists'] is True:
+                    return 0
+
+            return 2
+
+        else:
+           return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except json.JSONDecodeError:
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   user = input ("Username?: ").strip()
+   result = validate_gitlab(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occurred!")

user_scanner-1.0.0.0/user_scanner/dev/launchpad.py

@@ -0,0 +1,39 @@
+import httpx
+from httpx import ConnectError, TimeoutException
+
+def validate_launchpad(user):
+    url = f"https://launchpad.net/~{user}"
+
+    headers = {
+        'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Mobile Safari/537.36",
+        'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9",
+        'Accept-Encoding': "gzip, deflate, br, zstd",
+        'Upgrade-Insecure-Requests': "1",
+    }
+
+    try:
+        response = httpx.head(url, headers=headers, timeout=5.0, follow_redirects=True)
+        status = response.status_code
+
+        if status == 200:
+           return 0
+        elif status == 404:
+           return 1
+        else:
+           return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   user = input ("Username?: ").strip()
+   result = validate_launchpad(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occurred!")

user_scanner-1.0.0.0/user_scanner/dev/npmjs.py

@@ -0,0 +1,40 @@
+import httpx
+from httpx import ConnectError, TimeoutException
+
+def validate_npmjs(user):
+    url = f"https://www.npmjs.com/~{user}"
+
+    headers = {
+	  'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
+	  'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+	  'Accept-Encoding': "gzip, deflate, br, zstd",
+	  'accept-language': "en-US,en;q=0.9",
+	  'priority': "u=0, i"
+}
+
+    try:
+        response = httpx.head(url, headers=headers, timeout=3.0, follow_redirects=True)
+        status = response.status_code
+
+        if status == 200:
+           return 0
+        elif status == 404:
+           return 1
+        else:
+           return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   user = input ("Username?: ").strip()
+   result = validate_npmjs(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occurred!")

user_scanner-1.0.0.0/user_scanner/dev/replit.py

@@ -0,0 +1,37 @@
+import httpx
+from httpx import ConnectError, TimeoutException
+
+def validate_replit(user):
+    url = f"https://replit.com/@{user}"
+
+    headers = {
+        'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Mobile Safari/537.36",
+        'Accept': "text/html",
+    }
+
+    try:
+        response = httpx.head(url, headers=headers, timeout=3.0, follow_redirects=True)
+        status = response.status_code
+
+        if status == 200:
+           return 0
+        elif status == 404:
+           return 1
+        else:
+           return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   user = input ("Username?: ").strip()
+   result = validate_replit(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occurred!")

user_scanner-1.0.0.0/user_scanner/social/__init__.py

@@ -0,0 +1 @@
+# social

user_scanner-1.0.0.0/user_scanner/social/instagram.py

@@ -0,0 +1,48 @@
+import httpx
+from httpx import ConnectError, TimeoutException
+
+def validate_instagram(user):
+    url = f"https://www.instagram.com/api/v1/users/web_profile_info/?username={user}"
+
+    headers = {
+        'User-Agent': "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+        'X-IG-App-ID': "936619743392459",
+        'Accept': "application/json, text/javascript, */*; q=0.01",
+        'Accept-Encoding': "gzip, deflate, br",
+        'Accept-Language': "en-US,en;q=0.9",
+        'X-Requested-With': "XMLHttpRequest",
+        'Referer': f"https://www.instagram.com/{user}/",
+    }
+    
+    try:
+        response = httpx.get(url, headers=headers, timeout = 15.0)
+        status = response.status_code
+
+        if status == 200:
+           return 0
+        elif status == 404:
+           return 1
+        else:
+           return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   try:
+       import httpx
+   except ImportError:
+       print("Error: 'httpx' library is not installed.")
+       exit()
+
+   user = input ("Username?: ").strip()
+   result = validate_instagram(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occured!")

user_scanner-1.0.0.0/user_scanner/social/pinterest.py

@@ -0,0 +1,48 @@
+import httpx
+from httpx import ConnectError, TimeoutException
+
+def validate_pinterest(user):
+    url = f"https://www.pinterest.com/{user}/"
+
+    headers = {
+      'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Mobile Safari/537.36",
+      'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+      'Accept-Encoding': "gzip",
+      'Accept-Language': "en-US,en;q=0.9",
+      'sec-fetch-dest': "document",
+    }
+
+    NOT_FOUND_STRING = "User not found."
+
+    try:
+        response = httpx.get(url, headers=headers, follow_redirects=True, timeout = 3.0)
+
+        if response.status_code == 200:
+            if NOT_FOUND_STRING in response.text:
+                return 1
+            else:
+                return 0
+        else:
+           return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   try:
+       import httpx
+   except ImportError:
+       print("Error: 'httpx' library is not installed.")
+       exit()
+
+   user = input ("Username?: ").strip()
+   result = validate_pinterest(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occured!")

user_scanner-1.0.0.0/user_scanner/social/reddit.py

@@ -0,0 +1,48 @@
+import httpx
+from httpx import ConnectError, TimeoutException
+
+def validate_reddit(user):
+    url = f"https://www.reddit.com/user/{user}/"
+
+    headers = {
+      'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Safari/537.36",
+      'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+      'Accept-Encoding': "gzip, deflate, br",
+      'Accept-Language': "en-US,en;q=0.9",
+      'sec-fetch-dest': "document",
+    }
+
+    NOT_FOUND_STRING = "Sorry, nobody on Reddit goes by that name."
+
+    try:
+        response = httpx.get(url, headers=headers, follow_redirects=True, timeout = 3.0)
+
+        if response.status_code == 200:
+            if NOT_FOUND_STRING in response.text:
+                return 1
+            else:
+                return 0
+        else:
+           return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   try:
+       import httpx
+   except ImportError:
+       print("Error: 'httpx' library is not installed.")
+       exit()
+
+   user = input ("Username?: ").strip()
+   result = validate_reddit(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occured!")

user_scanner-1.0.0.0/user_scanner/social/snapchat.py

@@ -0,0 +1,54 @@
+import httpx
+from httpx import ConnectError, TimeoutException
+
+def validate_snapchat(user):
+    url = f"https://www.snapchat.com/@{user}"
+
+    headers = {
+      'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Mobile Safari/537.36",
+      'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+      'Accept-Encoding': "gzip, deflate, br, zstd",
+      'sec-ch-ua': "\"Google Chrome\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"",
+      'sec-ch-ua-mobile': "?1",
+      'sec-ch-ua-platform': "\"Android\"",
+      'upgrade-insecure-requests': "1",
+      'sec-fetch-site': "none",
+      'sec-fetch-mode': "navigate",
+      'sec-fetch-user': "?1",
+      'sec-fetch-dest': "document",
+      'accept-language': "en-US,en;q=0.9",
+      'priority': "u=0, i"
+    }
+
+    try:
+        response = httpx.get(url, headers=headers, follow_redirects=True, timeout = 3.0)
+        status = response.status_code
+
+        if status == 200:
+           return 0
+        elif status == 404:
+           return 1
+        else:
+           return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   try:
+       import httpx
+   except ImportError:
+       print("Error: 'httpx' library is not installed.")
+       exit()
+
+   user = input ("Username?: ").strip()
+   result = validate_snapchat(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occured!")

user_scanner-1.0.0.0/user_scanner/social/threads.py

@@ -0,0 +1,48 @@
+import httpx
+from httpx import ConnectError, TimeoutException
+
+def validate_instagram(user):
+    url = f"https://www.threads.com/api/v1/users/web_profile_info/?username={user}"
+
+    headers = {
+        'User-Agent': "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+        'X-IG-App-ID': "936619743392459",
+        'Accept': "application/json, text/javascript, */*; q=0.01",
+        'Accept-Encoding': "gzip, deflate, br",
+        'Accept-Language': "en-US,en;q=0.9",
+        'X-Requested-With': "XMLHttpRequest",
+        'Referer': f"https://www.instagram.com/{user}/",
+    }
+    
+    try:
+        response = httpx.get(url, headers=headers, timeout = 3.0)
+        status = response.status_code
+
+        if status == 200:
+           return 0
+        elif status == 404:
+           return 1
+        else:
+           return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   try:
+       import httpx
+   except ImportError:
+       print("Error: 'httpx' library is not installed.")
+       exit()
+
+   user = input ("Username?: ").strip()
+   result = validate_instagram(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occured!")

user_scanner-1.0.0.0/user_scanner/social/x.py

@@ -0,0 +1,56 @@
+import httpx
+import json
+from httpx import ConnectError, TimeoutException
+
+def validate_x(user):
+    url = "https://api.twitter.com/i/users/username_available.json"
+    
+    params = {
+        "username": user,
+        "full_name": "Test User",
+        "email": "test@example.com"
+    }
+
+    headers = {
+        "Authority": "api.twitter.com",
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36",
+    }
+
+    try:
+        response = httpx.get(url, params=params, headers=headers, timeout = 3.0)
+        status = response.status_code
+
+        if status in [401, 403, 429]:
+            return 2
+        
+        elif status == 200:
+            data = response.json()
+            
+            if data.get('valid') is True:
+                return 1
+            elif data.get('reason') == 'taken':
+                return 0
+            else:
+                return 2
+
+    except (ConnectError, TimeoutException, json.JSONDecodeError):
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   try:
+       import httpx
+   except ImportError:
+       print("Error: 'httpx' library is not installed.")
+       exit()
+
+   user = input ("Username?: ").strip()
+   result = validate_x(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occured!")

user_scanner-1.0.0.0/user_scanner/social/youtube.py

@@ -0,0 +1,62 @@
+import httpx
+from httpx import ConnectError, TimeoutException
+
+def validate_youtube(user):
+    url = f"https://m.youtube.com/@{user}"
+
+    headers = {
+      'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/141.0.0.0 Mobile Safari/537.36",
+      'Accept': "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+      'Accept-Encoding': "gzip, deflate, br, zstd",
+      'device-memory': "4",
+      'sec-ch-ua': "\"Google Chrome\";v=\"141\", \"Not?A_Brand\";v=\"8\", \"Chromium\";v=\"141\"",
+      'sec-ch-ua-mobile': "?1",
+      'sec-ch-ua-full-version': "\"141.0.7390.111\"",
+      'sec-ch-ua-arch': "\"\"",
+      'sec-ch-ua-platform': "\"Android\"",
+      'sec-ch-ua-platform-version': "\"15.0.0\"",
+      'sec-ch-ua-bitness': "\"\"",
+      'sec-ch-ua-wow64': "?0",
+      'sec-ch-ua-full-version-list': "\"Google Chrome\";v=\"141.0.7390.111\", \"Not?A_Brand\";v=\"8.0.0.0\", \"Chromium\";v=\"141.0.7390.111\"",
+      'sec-ch-ua-form-factors': "\"Mobile\"",
+      'upgrade-insecure-requests': "1",
+      'sec-fetch-site': "none",
+      'sec-fetch-mode': "navigate",
+      'sec-fetch-user': "?1",
+      'sec-fetch-dest': "document",
+      'accept-language': "en-US,en;q=0.9",
+      'priority': "u=0, i"
+    }
+
+    try:
+        response = httpx.get(url, headers=headers, follow_redirects=True, timeout = 3.0)
+        status = response.status_code
+
+        if status == 200:
+           return 0
+        elif status == 404:
+           return 1
+        else:
+           return 2
+
+    except (ConnectError, TimeoutException):
+        return 2
+    except Exception:
+        return 2
+
+if __name__ == "__main__":
+   try:
+       import httpx
+   except ImportError:
+       print("Error: 'httpx' library is not installed.")
+       exit()
+
+   user = input ("Username?: ").strip()
+   result = validate_youtube(user)
+
+   if result == 1:
+      print("Available!")
+   elif result == 0:
+      print("Unavailable!")
+   else:
+      print("Error occured!")