user-scanner 1.0.10.3__py3-none-any.whl → 1.1.0.1__py3-none-any.whl

user_scanner/email_scan/adult/xvideos.py

@@ -0,0 +1,50 @@
+import httpx
+from user_scanner.core.result import Result
+
+
+async def _check(email: str) -> Result:
+    url = "https://www.xvideos.com/account/checkemail"
+    params = {'email': email}
+
+    headers = {
+        'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36",
+        'Accept': "application/json, text/javascript, */*; q=0.01",
+        'Accept-Encoding': "identity",
+        'X-Requested-With': "XMLHttpRequest",
+        'sec-ch-ua-platform': "\"Android\"",
+        'sec-ch-ua': "\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"",
+        'sec-ch-ua-mobile': "?1",
+        'Sec-Fetch-Site': "same-origin",
+        'Sec-Fetch-Mode': "cors",
+        'Sec-Fetch-Dest': "empty",
+        'Referer': "https://www.xvideos.com/",
+        'Accept-Language': "en-US,en;q=0.9"
+    }
+
+    async with httpx.AsyncClient(http2=True, timeout=3) as client:
+        try:
+            response = await client.get(url, params=params, headers=headers)
+
+            if response.status_code == 429:
+                return Result.error("Rate limited, wait for a few minutes")
+
+            if response.status_code != 200:
+                return Result.error(f"HTTP Error: {response.status_code}")
+
+            data = response.json()
+
+            exists_bool = data.get("result")
+
+            if exists_bool is True:
+                return Result.available()
+            elif exists_bool is False:
+                return Result.taken()
+            else:
+                return Result.error("Unexpected error, report it via GitHub issues")
+
+        except Exception as e:
+            return Result.error(e)
+
+
+async def validate_xvideos(email: str) -> Result:
+    return await _check(email)

user_scanner/email_scan/community/stackoverflow.py

@@ -0,0 +1,40 @@
+import httpx
+from user_scanner.core.result import Result
+
+async def _check(email: str) -> Result:
+    async with httpx.AsyncClient(http2=False, follow_redirects=True) as client:
+        try:
+            url = "https://stackoverflow.com/users/login"
+
+            payload = {
+                'ssrc': "login",
+                'email': email,
+                'password': "Password109-grt",
+                'oauth_version': "",
+                'oauth_server': ""
+            }
+
+            headers = {
+                'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.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': "identity",
+                'sec-ch-ua-platform': '"Linux"',
+                'origin': "https://stackoverflow.com",
+                'referer': "https://stackoverflow.com/users/login"
+            }
+
+            response = await client.post(url, data=payload, headers=headers)
+            body = response.text
+
+            if "No user found with matching email" in body:
+                return Result.available()
+            elif "The email or password is incorrect" in body:
+                return Result.taken()
+            else:
+                return Result.error("Unexpected response body")
+
+        except Exception as e:
+            return Result.error(f"unexpected exception: {e}")
+
+async def validate_stackoverflow(email: str) -> Result:
+    return await _check(email)

user_scanner/email_scan/creator/gumroad.py

@@ -0,0 +1,82 @@
+import httpx
+import re
+from user_scanner.core.result import Result
+
+
+async def _check(email: str) -> Result:
+    async with httpx.AsyncClient(http2=False, follow_redirects=True) as client:
+        try:
+            url1 = "https://gumroad.com/users/forgot_password/new"
+            headers1 = {
+                'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.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",
+                'Accept-Encoding': "gzip, deflate, br, zstd",
+                'sec-ch-ua': '"Not(A:Brand";v="8", "Chromium";v="144", "Google Chrome";v="144"',
+                'sec-ch-ua-mobile': "?0",
+                'sec-ch-ua-platform': '"Linux"',
+                'upgrade-insecure-requests': "1",
+                'referer': "https://www.google.com/",
+                'accept-language': "en-US,en;q=0.9"
+            }
+
+            res1 = await client.get(url1, headers=headers1)
+            html = res1.text
+
+            csrf_match = re.search(
+                r'authenticity_token":"([^&]+)"', html)
+            if not csrf_match:
+                csrf_match = re.search(
+                    r'name="csrf-token" content="([^"]+)"', html)
+
+            if not csrf_match:
+                return Result.error("Failed to extract CSRF token")
+
+            csrf_token = csrf_match.group(1)
+
+            url2 = "https://gumroad.com/users/forgot_password"
+
+            payload = {
+                "user": {
+                    "email": email
+                }
+            }
+
+            headers2 = {
+                'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36",
+                'Accept': "text/html, application/xhtml+xml",
+                'Accept-Encoding': "gzip, deflate, br, zstd",
+                'Content-Type': "application/json",
+                'sec-ch-ua-platform': '"Linux"',
+                'x-csrf-token': csrf_token,
+                'sec-ch-ua': '"Not(A:Brand";v="8", "Chromium";v="144", "Google Chrome";v="144"',
+                'x-inertia': "true",
+                'sec-ch-ua-mobile': "?0",
+                'x-requested-with': "XMLHttpRequest",
+                'origin': "https://gumroad.com",
+                'sec-fetch-site': "same-origin",
+                'sec-fetch-mode': "cors",
+                'sec-fetch-dest': "empty",
+                'referer': "https://gumroad.com/users/forgot_password/new",
+                'accept-language': "en-US,en;q=0.9",
+                'priority': "u=1, i"
+            }
+
+            response = await client.post(url2, json=payload, headers=headers2)
+
+            data = response.json()
+            flash_msg = data.get("props", {}).get(
+                "flash", {}).get("message", "")
+
+            if "An account does not exist" in flash_msg:
+                return Result.available()
+            elif "An account does not exist" not in flash_msg:
+                return Result.taken()
+            else:
+                return Result.error(f"Unexpected status: {response.status_code}")
+
+        except Exception as e:
+            return Result.error(f"unexpected exception: {e}")
+
+
+async def validate_gumroad(email: str) -> Result:
+    return await _check(email)

user_scanner/email_scan/creator/patreon.py

@@ -0,0 +1,58 @@
+import httpx
+from user_scanner.core.result import Result
+
+
+async def _check(email: str) -> Result:
+    async with httpx.AsyncClient(http2=False) as client:
+        try:
+            url = "https://www.patreon.com/api/auth"
+
+            params = {
+                'include': "user.null",
+                'fields[user]': "[]",
+                'json-api-version': "1.0",
+                'json-api-use-default-includes': "false"
+            }
+
+            payload = "{\"data\":{\"type\":\"genericPatreonApi\",\"attributes\":{\"patreon_auth\":{\"email\":\"" + email + \
+                "\",\"allow_account_creation\":false},\"auth_context\":\"auth\",\"ru\":\"https://www.patreon.com/home\"},\"relationships\":{}}}"
+
+            headers = {
+                'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36",
+                'Accept-Encoding': "identity",
+                'content-type': "application/vnd.api+json",
+                'origin': "https://www.patreon.com"
+            }
+
+            response = await client.post(
+                url,
+                params=params,
+                content=payload,
+                headers=headers
+            )
+
+            if response.status_code != 200:
+                return Result.error(f"Status {response.status_code}")
+
+            data = response.json()
+            next_step = data.get("data", {}).get(
+                "attributes", {}).get("next_auth_step")
+
+            if next_step == "password":
+                return Result.taken()
+            elif next_step == "signup":
+                return Result.available()
+            else:
+                return Result.error("Unexpected auth step")
+
+        except Exception as e:
+            return Result.error(f"unexpected exception: {e}")
+
+
+async def validate_patreon(email: str) -> Result:
+    return await _check(email)
+
+
+
+
+

user_scanner/email_scan/dev/bitbucket.py

@@ -0,0 +1,33 @@
+import httpx
+from user_scanner.core.result import Result
+
+async def _check(email: str) -> Result:
+    async with httpx.AsyncClient(http2=True) as client:
+        try:
+            url = "https://id.atlassian.com/rest/marketing-consent/config"
+            payload = {"email": email}
+            headers = {
+                'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36",
+                'Content-Type': "application/json",
+                'Origin': "https://id.atlassian.com",
+                'Referer': f"https://id.atlassian.com/login?email={email}"
+            }
+
+            response = await client.post(url, json=payload, headers=headers)
+
+            if response.status_code != 200:
+                return Result.error(f"Status {response.status_code}")
+
+            data = response.json()
+            is_reg = data.get("implicitConsent")
+            if is_reg is True:
+                return Result.available()
+            elif is_reg is False:
+                return Result.taken()
+            else:
+                return Result.error(f"Unexpected error occured [{response.status_code}]")
+        except Exception as e:
+            return Result.error(f"Unexpected exception:{e}")
+
+async def validate_bitbucket(email: str) -> Result:
+    return await _check(email)

user_scanner/email_scan/dev/github.py

@@ -0,0 +1,72 @@
+import httpx
+import re
+from user_scanner.core.result import Result
+
+async def _check(email: str) -> Result:
+    async with httpx.AsyncClient(http2=True, follow_redirects=True) as client:
+        try:
+            url1 = "https://github.com/signup"
+            headers1 = {
+                'host': 'github.com',
+                'sec-ch-ua': '"Not(A:Brand";v="8", "Chromium";v="144", "Google Chrome";v="144"',
+                'sec-ch-ua-mobile': '?0',
+                'sec-ch-ua-platform': '"Linux"',
+                'upgrade-insecure-requests': '1',
+                'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.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',
+                'sec-fetch-site': 'cross-site',
+                'sec-fetch-mode': 'navigate',
+                'sec-fetch-user': '?1',
+                'sec-fetch-dest': 'document',
+                'referer': 'https://www.google.com/',
+                'accept-encoding': 'gzip, deflate, br, zstd',
+                'accept-language': 'en-US,en;q=0.9',
+                'priority': 'u=0, i'
+            }
+
+            res1 = await client.get(url1, headers=headers1)
+            html = res1.text
+
+            csrf_match = re.search(r'data-csrf="true"\s+value="([^"]+)"', html)
+
+            if not csrf_match:
+                return Result.error("Failed to extract GitHub authenticity_token")
+
+            csrf_token = csrf_match.group(1)
+
+            url2 = "https://github.com/email_validity_checks"
+            payload = {
+                'authenticity_token': csrf_token,
+                'value': email
+            }
+
+            headers2 = {
+                'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36",
+                'Accept-Encoding': "gzip, deflate, br, zstd",
+                'sec-ch-ua-platform': '"Linux"',
+                'sec-ch-ua': '"Not(A:Brand";v="8", "Chromium";v="144", "Google Chrome";v="144"',
+                'sec-ch-ua-mobile': "?0",
+                'origin': "https://github.com",
+                'sec-fetch-site': "same-origin",
+                'sec-fetch-mode': "cors",
+                'sec-fetch-dest': "empty",
+                'referer': "https://github.com/signup",
+                'accept-language': "en-US,en;q=0.9",
+                'priority': "u=1, i"
+            }
+
+            response = await client.post(url2, data=payload, headers=headers2)
+            body = response.text
+
+            if "already associated with an account" in body:
+                return Result.taken()
+            elif response.status_code == 200 and "Email is available" in body:
+                return Result.available()
+            else:
+                return Result.error(f"Unexpected status code: {response.status_code}, report this via GitHub issues")
+
+        except Exception as e:
+            return Result.error(f"unexpected exception: {e}")
+
+async def validate_github(email: str) -> Result:
+    return await _check(email)

user_scanner/email_scan/dev/huggingface.py

@@ -0,0 +1,37 @@
+import httpx
+from user_scanner.core.result import Result
+
+
+async def _check(email: str) -> Result:
+    url = "https://huggingface.co/api/check-user-email"
+    params = {'email': email}
+    headers = {
+        'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
+        'Accept-Encoding': "identity",
+        'referer': "https://huggingface.co/join",
+        'priority': "u=1, i"
+    }
+
+    async with httpx.AsyncClient(http2=True) as client:
+        try:
+            response = await client.get(url, params=params, headers=headers, timeout=5)
+
+            if response.status_code == 429:
+                return Result.error("Rate limited wait for few minutes")
+
+            if response.status_code == 400:
+                data = response.json()
+                if "already exists" in data.get("error", ""):
+                    return Result.taken()
+
+            if response.status_code == 200:
+                return Result.available()
+
+            return Result.error(f"HTTP Error: {response.status_code}")
+
+        except Exception as e:
+            return Result.error(e)
+
+
+async def validate_huggingface(email: str) -> Result:
+    return await _check(email)

user_scanner/email_scan/gaming/chess_com.py

@@ -0,0 +1,47 @@
+import httpx
+from user_scanner.core.result import Result
+
+async def _check(email: str) -> Result:
+    async with httpx.AsyncClient(http2=True) as client:
+        try:
+            url = "https://www.chess.com/rpc/chesscom.authentication.v1.EmailValidationService/Validate"
+
+            payload = {
+                "email": email
+            }
+
+            headers = {
+                'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Mobile Safari/537.36",
+                'Accept': "application/json, text/plain, */*",
+                'Accept-Encoding': "identity",
+                'Content-Type': "application/json",
+                'sec-ch-ua-platform': '"Android"',
+                'accept-language': "en_US",
+                'connect-protocol-version': "1",
+                'origin': "https://www.chess.com",
+                'sec-fetch-site': "same-origin",
+                'sec-fetch-mode': "cors",
+                'referer': "https://www.chess.com/register",
+                'priority': "u=1, i"
+            }
+
+            response = await client.post(url, json=payload, headers=headers)
+
+            if response.status_code != 200:
+                return Result.error(f"Status {response.status_code}, report is via GitHub issues")
+
+            data = response.json()
+            status = data.get("status")
+
+            if status == "EMAIL_STATUS_TAKEN":
+                return Result.taken()
+            elif status == "EMAIL_STATUS_AVAILABLE":
+                return Result.available()
+            else:
+                return Result.error(f"Unknown status: {status}, report is via GitHub issues")
+
+        except Exception as e:
+            return Result.error(f"unexpected exception: {e}")
+
+async def validate_chess_com(email: str) -> Result:
+    return await _check(email)

user_scanner/email_scan/shopping/flipkart.py

@@ -0,0 +1,52 @@
+import httpx
+from user_scanner.core.result import Result
+
+async def _check(email: str) -> Result:
+    url = "https://1.rome.api.flipkart.com/1/action/view"
+
+    headers = {
+        'User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36",
+        'Content-Type': "application/json",
+        'X-User-Agent': "Mozilla/5.0 (Linux; Android 10; K) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Mobile Safari/537.36 FKUA/msite/0.0.3/msite/Mobile channelType/undefined",
+        'Origin': "https://www.flipkart.com",
+        'Referer': "https://www.flipkart.com/"
+    }
+
+    payload = {
+        "actionRequestContext": {
+            "type": "LOGIN_IDENTITY_VERIFY",
+            "loginIdPrefix": "",
+            "loginId": email,
+            "clientQueryParamMap": {"ret": "/"},
+            "loginType": "EMAIL",
+            "verificationType": "PASSWORD",
+            "screenName": "LOGIN_V4_EMAIL",
+            "sourceContext": "DEFAULT"
+        }
+    }
+
+    async with httpx.AsyncClient(http2=True) as client:
+        try:
+            response = await client.post(url, json=payload, headers=headers)
+
+            if response.status_code == 429:
+                return Result.error("Rate limited wait for few minutes")
+
+            if response.status_code != 200:
+                return Result.error(f"HTTP Error: {response.status_code}")
+
+            response_text = response.text
+
+            if "Looks like you're new here!" in response_text:
+                return Result.available()
+
+            if "LOGIN_P_CHECK" in response_text or '"statusSuccess":true' in response_text:
+                return Result.taken()
+
+            return Result.taken()
+
+        except Exception as e:
+            return Result.error(e)
+
+async def validate_flipkart(email: str) -> Result:
+    return await _check(email)

user_scanner/email_scan/social/facebook.py

@@ -0,0 +1,96 @@
+import httpx
+import re
+from user_scanner.core.result import Result
+
+async def _check(email: str) -> Result:
+    async with httpx.AsyncClient(http2=True, follow_redirects=False) as client:
+        try:
+            url1 = "https://m.facebook.com/login/"
+            headers1 = {
+                'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.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': "identity",
+                'sec-ch-ua': '"Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"',
+            }
+            await client.get(url1, headers=headers1)
+
+            url2 = "https://www.facebook.com"
+            params2 = {'_rdr': ""}
+            headers2 = {
+                'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.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': "identity",
+                'upgrade-insecure-requests': "1",
+                'sec-fetch-site': "cross-site",
+                'sec-fetch-mode': "navigate",
+                'sec-fetch-user': "?1",
+                'sec-fetch-dest': "document",
+                'sec-ch-ua': '"Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"',
+                'sec-ch-ua-mobile': "?0",
+                'sec-ch-ua-platform': '"Linux"',
+                'referer': "https://www.google.com/",
+                'accept-language': "en-US,en;q=0.9",
+                'priority': "u=0, i"
+            }
+            res2 = await client.get(url2, params=params2, headers=headers2)
+            html = res2.text
+
+            j_match = re.search(r'name="jazoest" value="(\d+)"', html)
+            l_match = re.search(r'name="lsd" value="([^"]+)"', html)
+
+            if not j_match or not l_match:
+                return Result.error("Failed to extract tokens (LSD/Jazoest)")
+
+            jazoest = j_match.group(1)
+            lsd = l_match.group(1)
+
+            url3 = "https://www.facebook.com/ajax/login/help/identify.php"
+            params3 = {'ctx': "recover"}
+
+            payload3 = {
+                'jazoest': jazoest,
+                'lsd': lsd,
+                'email': email,
+                'did_submit': "1",
+                '__user': "0",
+                '__a': "1",
+                '__req': "7"
+            }
+
+            headers3 = {
+                'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
+                'Accept-Encoding': "identity",
+                'sec-ch-ua-full-version-list': '"Google Chrome";v="143.0.7499.192", "Chromium";v="143.0.7499.192", "Not A(Brand";v="24.0.0.0"',
+                'sec-ch-ua-platform': '"Linux"',
+                'sec-ch-ua': '"Google Chrome";v="143", "Chromium";v="143", "Not A(Brand";v="24"',
+                'sec-ch-ua-model': '""',
+                'sec-ch-ua-mobile': "?0",
+                'x-asbd-id': "359341",
+                'x-fb-lsd': lsd,
+                'sec-ch-prefers-color-scheme': "dark",
+                'sec-ch-ua-platform-version': '""',
+                'origin': "https://www.facebook.com",
+                'sec-fetch-site': "same-origin",
+                'sec-fetch-mode': "cors",
+                'sec-fetch-dest': "empty",
+                'referer': "https://www.facebook.com/login/identify/?ctx=recover&ars=facebook_login&from_login_screen=0",
+                'accept-language': "en-US,en;q=0.9",
+                'priority': "u=1, i"
+            }
+
+            response = await client.post(url3, params=params3, data=payload3, headers=headers3)
+            body = response.text
+
+            if "redirectPageTo" in body and "ServerRedirect" in body:
+                return Result.taken()
+            elif "No search results" in body or "Your search did not return any results." in body:
+                return Result.available()
+            else:
+                return Result.error("Unexpected error, report it via GitHub issues")
+
+        except Exception as e:
+            return Result.error(f"Unexpected exception: {e}")
+
+async def validate_facebook(email: str) -> Result:
+    return await _check(email)
+

user_scanner/email_scan/social/instagram.py

@@ -0,0 +1,48 @@
+import httpx
+from user_scanner.core.result import Result
+
+
+async def _check(email):
+    USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"
+    async with httpx.AsyncClient(headers={"user-agent": USER_AGENT}, http2=True) as client:
+        await client.get("https://www.instagram.com/")
+        csrf = client.cookies.get("csrftoken")
+
+        headers = {
+            "x-csrftoken": csrf,
+            'User-Agent': "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
+            'Accept-Encoding': "identity",
+            'sec-ch-ua-full-version-list': "\"Google Chrome\";v=\"143.0.7499.146\", \"Chromium\";v=\"143.0.7499.146\", \"Not A(Brand\";v=\"24.0.0.0\"",
+            'sec-ch-ua-platform': "\"Linux\"",
+            'sec-ch-ua': "\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"",
+            'sec-ch-ua-model': "\"\"",
+            'sec-ch-ua-mobile': "?0",
+            'x-ig-app-id': "936619743392459",
+            'x-requested-with': "XMLHttpRequest",
+            'x-instagram-ajax': "1031566424",
+            'x-asbd-id': "359341",
+            'x-ig-www-claim': "0",
+            'sec-ch-ua-platform-version': "\"\"",
+            'origin': "https://www.instagram.com",
+            'referer': "https://www.instagram.com/accounts/password/reset/"
+        }
+
+        response = await client.post(
+            "https://www.instagram.com/api/v1/web/accounts/account_recovery_send_ajax/",
+            data={"email_or_username": email},
+            headers=headers
+        )
+
+        data = response.json()
+        status_val = data.get("status")
+        if status_val == "ok":
+            return Result.taken()
+        elif status_val == "fail":
+            return Result.available()
+        else:
+            return Result.error("Unexpected response body, report it on github")
+
+
+
+async def validate_instagram(email: str) -> Result:
+    return await _check(email)