Update app.py

app.py

@@ -1,20 +1,23 @@
 import requests
 from bs4 import BeautifulSoup
-from fastapi import FastAPI, BackgroundTasks, HTTPException, Form
+from fastapi import FastAPI, HTTPException, Form
 from fastapi.responses import PlainTextResponse, HTMLResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 import re
-from concurrent.futures import ThreadPoolExecutor
 import urllib.parse
-import gradio as gr
 import fake_useragent as fake
 import random
 from dotenv import load_dotenv
 import os
-from tqdm import tqdm
 from faker import Faker
-import faker as fakexd
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.common.action_chains import ActionChains
+import time
+from webdriver_manager.chrome import ChromeDriverManager
 
 load_dotenv()
 
@@ -23,6 +26,7 @@ app = FastAPI()
 class Proxy(BaseModel):
     ip: str
     port: str
+    type: str
 
 class VisitRequest(BaseModel):
     url: str
@@ -34,27 +38,39 @@ class VisitRequest(BaseModel):
 app.mount("/static", StaticFiles(directory="static"), name="static")
 
 def get_random_proxy():
-    pubproxy_url = "http://pubproxy.com/api/proxy?limit=1&type=http"
-    response = requests.get(pubproxy_url, verify=False)
-    data = response.json()
-    if data['data']:
-        proxy_data = data['data'][0]
-        return f"{proxy_data['ip']}:{proxy_data['port']}"
-    return None
+    try:
+        options = webdriver.ChromeOptions()
+        options.add_argument('--headless')
+        options.add_argument('--disable-gpu')
+        options.add_argument('--no-sandbox')
+        driver = webdriver.Chrome(ChromeDriverManager().install(), options=options)
+        driver.get("https://uhhy-fsfsfs.hf.space/valid")
+        WebDriverWait(driver, 10).until(
+            EC.presence_of_element_located((By.CSS_SELECTOR, "table tbody tr"))
+        )
+        proxy_elements = driver.find_elements(By.CSS_SELECTOR, "table tbody tr")
+        proxies = []
+        for element in proxy_elements:
+            ip = element.find_element(By.CSS_SELECTOR, "td:nth-child(1)").text
+            port = element.find_element(By.CSS_SELECTOR, "td:nth-child(2)").text
+            proxy_type = element.find_element(By.CSS_SELECTOR, "td:nth-child(3)").text.lower()
+            proxies.append(Proxy(ip=ip, port=port, type=proxy_type))
+        driver.quit()
+        if proxies:
+            return random.choice(proxies)
+        else:
+            return None
+    except Exception as e:
+        return None
 
 @app.get("/get_proxies", response_class=PlainTextResponse)
 def get_proxies():
     try:
         proxies = []
-        pubproxy_url = "http://pubproxy.com/api/proxy?limit=5&type=http"
-        response = requests.get(pubproxy_url, verify=False)
-        data = response.json()
-
-        for proxy_data in data['data']:
-            ip, port = proxy_data['ipPort'].split(":")
-            proxy = f"{ip}:{port}"
-            proxies.append(proxy)
-        
+        for _ in range(5):
+            proxy = get_random_proxy()
+            if proxy:
+                proxies.append(f"{proxy.ip}:{proxy.port} ({proxy.type})")
         return "\n".join(proxies)
     except Exception as e:
         return PlainTextResponse(str(e), status_code=500)
@@ -64,24 +80,15 @@ def rotate_ip():
     try:
         fake = Faker()
         random_ip = fake.ipv4()
-
         headers = {
             "X-Forwarded-For": random_ip,
             "Client-IP": random_ip,
             "X-Real-IP": random_ip
         }
-
-        test_url = "http://pubproxy.com/api/proxy?limit=1&type=http&https=true&speed=60"
-        response = requests.get(test_url, headers=headers, verify=False)
-        data = response.json()
-
-        proxies = []
-        for proxy_data in data['data']:
-            ip, port = proxy_data['ipPort'].split(":")
-            proxy = f"{ip}:{port}"
-            proxies.append(proxy)
-
-        return "\n".join(proxies)
+        proxy = get_random_proxy()
+        if not proxy:
+            return PlainTextResponse("No proxy available.", status_code=500)
+        return PlainTextResponse(f"{proxy.ip}:{proxy.port} ({proxy.type})")
     except Exception as e:
         return PlainTextResponse(str(e), status_code=500)
 
@@ -101,7 +108,6 @@ def extract_video_id(url: str, platform: str) -> str:
         match = re.search(r"spotify\.com/track/([^/?]+)", url)
     else:
         match = None
-
     if match:
         return match.group(1)
     else:
@@ -110,24 +116,19 @@ def extract_video_id(url: str, platform: str) -> str:
 def instagram_login(username: str, password: str):
     login_url = "https://www.instagram.com/accounts/login/ajax/"
     session = requests.Session()
-
     response = session.get("https://www.instagram.com/", headers={"User-Agent": "Mozilla/5.0"})
     soup = BeautifulSoup(response.text, "html.parser")
     csrf_token = soup.find("meta", {"name": "csrf-token"})["content"]
-
     login_data = {
         "username": username,
         "enc_password": f"#PWD_INSTAGRAM_BROWSER:0:&:{password}"
     }
-
     headers = {
         "User-Agent": "Mozilla/5.0",
         "X-CSRFToken": csrf_token,
         "X-Requested-With": "XMLHttpRequest"
     }
-
     response = session.post(login_url, data=login_data, headers=headers)
-
     if response.status_code == 200 and response.json().get("authenticated"):
         return session
     else:
@@ -136,14 +137,11 @@ def instagram_login(username: str, password: str):
 def tiktok_login(username: str, password: str):
     login_url = "https://www.tiktok.com/login/"
     session = requests.Session()
-
     login_data = {
         "username": username,
         "password": password
     }
-
     response = session.post(login_url, data=login_data)
-
     if response.status_code == 200:
         return session
     else:
@@ -152,14 +150,11 @@ def tiktok_login(username: str, password: str):
 def youtube_login(username: str, password: str):
     login_url = "https://accounts.google.com/ServiceLogin"
     session = requests.Session()
-
     login_data = {
         "username": username,
         "password": password
     }
-
     response = session.post(login_url, data=login_data)
-
     if response.status_code == 200:
         return session
     else:
@@ -168,14 +163,11 @@ def youtube_login(username: str, password: str):
 def facebook_login(username: str, password: str):
     login_url = "https://www.facebook.com/login"
     session = requests.Session()
-
     login_data = {
         "email": username,
         "pass": password
     }
-
     response = session.post(login_url, data=login_data)
-
     if response.status_code == 200:
         return session
     else:
@@ -184,14 +176,11 @@ def facebook_login(username: str, password: str):
 def twitch_login(username: str, password: str):
     login_url = "https://www.twitch.tv/login"
     session = requests.Session()
-
     login_data = {
         "login": username,
         "password": password
     }
-
     response = session.post(login_url, data=login_data)
-
     if response.status_code == 200:
         return session
     else:
@@ -200,166 +189,367 @@ def twitch_login(username: str, password: str):
 def spotify_login(username: str, password: str):
     login_url = "https://accounts.spotify.com/api/token"
     session = requests.Session()
-
     login_data = {
         "username": username,
         "password": password
     }
-
     response = session.post(login_url, data=login_data)
-
     if response.status_code == 200:
         return session
     else:
         raise HTTPException(status_code=401, detail="Authentication failed")
 
-def simulate_instagram_view(video_id: str, proxy: str, session: requests.Session):
-    proxies = {
-        "http": f"http://{proxy}"
-    }
-    fake = Faker()
-    fake_ipv4 = fake.ipv4()
-    headers = {
-        "User-Agent": fake.user_agent(),
-        "X-Forwarded-For": fake_ipv4,
-        "Client-IP": fake_ipv4,
-        "X-Real-IP": fake_ipv4
+def simulate_instagram_view(video_id: str, proxy: Proxy, session: requests.Session):
+    webdriver.DesiredCapabilities.CHROME['proxy'] = {
+        "httpProxy": f"{proxy.ip}:{proxy.port}",
+        "ftpProxy": f"{proxy.ip}:{proxy.port}",
+        "sslProxy": f"{proxy.ip}:{proxy.port}",
+        "proxyType": "MANUAL",
     }
+    options = webdriver.ChromeOptions()
+    options.add_argument("--headless")
+    options.add_argument("--disable-blink-features=AutomationControlled")
+    options.add_argument("--disable-popup-blocking")
+    options.add_argument("--disable-infobars")
+    options.add_argument("--disable-web-security")
+    options.add_argument("--ignore-certificate-errors")
+    options.add_argument("--disable-notifications")
+    options.add_argument("--disable-extensions")
+    options.add_argument("--disable-gpu")
+    options.add_argument("--no-sandbox")
+    options.add_argument("--disable-dev-shm-usage")
+    options.add_argument("--mute-audio")
+    options.add_argument('--ignore-ssl-errors=yes')
+    options.add_argument('--ignore-certificate-errors')
+    driver = webdriver.Chrome(ChromeDriverManager().install(), options=options)
+
     try:
+        fake = Faker()
+        fake_ipv4 = fake.ipv4()
+        headers = {
+            "User-Agent": fake.user_agent(),
+            "X-Forwarded-For": fake_ipv4,
+            "Client-IP": fake_ipv4,
+            "X-Real-IP": fake_ipv4
+        }
         view_url = f"https://www.instagram.com/reel/{video_id}"
-        response = session.get(view_url, headers=headers, proxies=proxies)
-        embed_link = f"https://www.instagram.com/p/{video_id}/embed/?autoplay=true"
-        embed_link_with_start = f"{embed_link}?start={rand(4, 8)}"
-        print(embed_link_with_start)
-    except Exception as e:
-        print(f"Error in simulate_instagram_view: {e}")
 
-def simulate_tiktok_view(video_id: str, proxy: str, session: requests.Session):
-    proxies = {
-        "http": f"http://{proxy}"
-    }
-    fake = Faker()
-    fake_ipv4 = fake.ipv4()
-    headers = {
-        "User-Agent": fake.user_agent(),
-        "X-Forwarded-For": fake_ipv4,
-        "Client-IP": fake_ipv4,
-        "X-Real-IP": fake_ipv4
+        if proxy.type == "http" or proxy.type == "https":
+            response = session.get(view_url, headers=headers, proxies={"http": f"http://{proxy.ip}:{proxy.port}", "https": f"https://{proxy.ip}:{proxy.port}"})
+
+        driver.get(view_url)
+
+        try:
+            not_now = WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, 'mt3GC')))
+            a = not_now.find_elements(By.TAG_NAME, "button")[1]
+            actions = ActionChains(driver)
+            actions.click(a)
+            actions.perform()
+        except:
+            pass
+
+        time.sleep(rand(10, 20))
+    except Exception as e:
+        pass
+    finally:
+        driver.quit()
+
+def simulate_tiktok_view(video_id: str, proxy: Proxy, session: requests.Session):
+    webdriver.DesiredCapabilities.CHROME['proxy'] = {
+        "httpProxy": f"{proxy.ip}:{proxy.port}",
+        "ftpProxy": f"{proxy.ip}:{proxy.port}",
+        "sslProxy": f"{proxy.ip}:{proxy.port}",
+        "proxyType": "MANUAL",
     }
+    options = webdriver.ChromeOptions()
+    options.add_argument("--headless")
+    options.add_argument("--disable-blink-features=AutomationControlled")
+    options.add_argument("--disable-popup-blocking")
+    options.add_argument("--disable-infobars")
+    options.add_argument("--disable-web-security")
+    options.add_argument("--ignore-certificate-errors")
+    options.add_argument("--disable-notifications")
+    options.add_argument("--disable-extensions")
+    options.add_argument("--disable-gpu")
+    options.add_argument("--no-sandbox")
+    options.add_argument("--disable-dev-shm-usage")
+    options.add_argument("--mute-audio")
+    options.add_argument('--ignore-ssl-errors=yes')
+    options.add_argument('--ignore-certificate-errors')
+    driver = webdriver.Chrome(ChromeDriverManager().install(), options=options)
+
     try:
+        fake = Faker()
+        fake_ipv4 = fake.ipv4()
+        headers = {
+            "User-Agent": fake.user_agent(),
+            "X-Forwarded-For": fake_ipv4,
+            "Client-IP": fake_ipv4,
+            "X-Real-IP": fake_ipv4
+        }
         view_url = f"https://www.tiktok.com/@user/video/{video_id}"
-        response = session.get(view_url, headers=headers, proxies=proxies)
-        embed_link = f"https://www.tiktok.com/embed/v/{video_id}?autoplay=true"
-        embed_link_with_start = f"{embed_link}?start={rand(4, 8)}"
-        print(embed_link_with_start)
-    except Exception as e:
-        print(f"Error in simulate_tiktok_view: {e}")
 
-def simulate_youtube_view(video_id: str, proxy: str, session: requests.Session):
-    proxies = {
-        "http": f"http://{proxy}"
-    }
-    fake = Faker()
-    fake_ipv4 = fake.ipv4()
-    headers = {
-        "User-Agent": fake.user_agent(),
-        "X-Forwarded-For": fake_ipv4,
-        "Client-IP": fake_ipv4,
-        "X-Real-IP": fake_ipv4
+        if proxy.type == "http" or proxy.type == "https":
+            response = session.get(view_url, headers=headers, proxies={"http": f"http://{proxy.ip}:{proxy.port}", "https": f"https://{proxy.ip}:{proxy.port}"})
+
+        driver.get(view_url)
+
+        try:
+            not_now = WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, 'mt3GC')))
+            a = not_now.find_elements(By.TAG_NAME, "button")[1]
+            actions = ActionChains(driver)
+            actions.click(a)
+            actions.perform()
+        except:
+            pass
+
+        time.sleep(rand(10, 20))
+    except Exception as e:
+        pass
+    finally:
+        driver.quit()
+
+def simulate_youtube_view(video_id: str, proxy: Proxy, session: requests.Session):
+    webdriver.DesiredCapabilities.CHROME['proxy'] = {
+        "httpProxy": f"{proxy.ip}:{proxy.port}",
+        "ftpProxy": f"{proxy.ip}:{proxy.port}",
+        "sslProxy": f"{proxy.ip}:{proxy.port}",
+        "proxyType": "MANUAL",
     }
+    options = webdriver.ChromeOptions()
+    options.add_argument("--headless")
+    options.add_argument("--disable-blink-features=AutomationControlled")
+    options.add_argument("--disable-popup-blocking")
+    options.add_argument("--disable-infobars")
+    options.add_argument("--disable-web-security")
+    options.add_argument("--ignore-certificate-errors")
+    options.add_argument("--disable-notifications")
+    options.add_argument("--disable-extensions")
+    options.add_argument("--disable-gpu")
+    options.add_argument("--no-sandbox")
+    options.add_argument("--disable-dev-shm-usage")
+    options.add_argument("--mute-audio")
+    options.add_argument('--ignore-ssl-errors=yes')
+    options.add_argument('--ignore-certificate-errors')
+    driver = webdriver.Chrome(ChromeDriverManager().install(), options=options)
+
     try:
+        fake = Faker()
+        fake_ipv4 = fake.ipv4()
+        headers = {
+            "User-Agent": fake.user_agent(),
+            "X-Forwarded-For": fake_ipv4,
+            "Client-IP": fake_ipv4,
+            "X-Real-IP": fake_ipv4
+        }
         view_url = f"https://www.youtube.com/watch?v={video_id}"
-        response = session.get(view_url, headers=headers, proxies=proxies)
-        embed_link = f"https://www.youtube.com/embed/{video_id}?autoplay=true"
-        embed_link_with_start = f"{embed_link}?controls=0&start={rand(4, 8)}"
-        print(embed_link_with_start)
-    except Exception as e:
-        print(f"Error in simulate_youtube_view: {e}")
 
-def simulate_facebook_view(video_id: str, proxy: str, session: requests.Session):
-    proxies = {
-        "http": f"http://{proxy}"
-    }
-    fake = Faker()
-    fake_ipv4 = fake.ipv4()
-    headers = {
-        "User-Agent": fake.user_agent(),
-        "X-Forwarded-For": fake_ipv4,
-        "Client-IP": fake_ipv4,
-        "X-Real-IP": fake_ipv4
+        if proxy.type == "http" or proxy.type == "https":
+            response = session.get(view_url, headers=headers, proxies={"http": f"http://{proxy.ip}:{proxy.port}", "https": f"https://{proxy.ip}:{proxy.port}"})
+
+        driver.get(view_url)
+
+        try:
+            not_now = WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, 'mt3GC')))
+            a = not_now.find_elements(By.TAG_NAME, "button")[1]
+            actions = ActionChains(driver)
+            actions.click(a)
+            actions.perform()
+        except:
+            pass
+
+        time.sleep(rand(10, 20))
+    except Exception as e:
+        pass
+    finally:
+        driver.quit()
+
+def simulate_facebook_view(video_id: str, proxy: Proxy, session: requests.Session):
+    webdriver.DesiredCapabilities.CHROME['proxy'] = {
+        "httpProxy": f"{proxy.ip}:{proxy.port}",
+        "ftpProxy": f"{proxy.ip}:{proxy.port}",
+        "sslProxy": f"{proxy.ip}:{proxy.port}",
+        "proxyType": "MANUAL",
     }
+    options = webdriver.ChromeOptions()
+    options.add_argument("--headless")
+    options.add_argument("--disable-blink-features=AutomationControlled")
+    options.add_argument("--disable-popup-blocking")
+    options.add_argument("--disable-infobars")
+    options.add_argument("--disable-web-security")
+    options.add_argument("--ignore-certificate-errors")
+    options.add_argument("--disable-notifications")
+    options.add_argument("--disable-extensions")
+    options.add_argument("--disable-gpu")
+    options.add_argument("--no-sandbox")
+    options.add_argument("--disable-dev-shm-usage")
+    options.add_argument("--mute-audio")
+    options.add_argument('--ignore-ssl-errors=yes')
+    options.add_argument('--ignore-certificate-errors')
+    driver = webdriver.Chrome(ChromeDriverManager().install(), options=options)
+
     try:
+        fake = Faker()
+        fake_ipv4 = fake.ipv4()
+        headers = {
+            "User-Agent": fake.user_agent(),
+            "X-Forwarded-For": fake_ipv4,
+            "Client-IP": fake_ipv4,
+            "X-Real-IP": fake_ipv4
+        }
         view_url = f"https://www.facebook.com/{video_id}"
-        response = session.get(view_url, headers=headers, proxies=proxies)
-        embed_link = f"https://www.facebook.com/plugins/video.php?href=https://www.facebook.com/{video_id}/&show_text=0&width=560&height=315&autoplay=true"
-        embed_link_with_start = f"{embed_link}&start={rand(4, 8)}"
-        print(embed_link_with_start)
-    except Exception as e:
-        print(f"Error in simulate_facebook_view: {e}")
 
-def simulate_twitch_view(video_id: str, proxy: str, session: requests.Session):
-    proxies = {
-        "http": f"http://{proxy}"
-    }
-    fake = Faker()
-    fake_ipv4 = fake.ipv4()
-    headers = {
-        "User-Agent": fake.user_agent(),
-        "X-Forwarded-For": fake_ipv4,
-        "Client-IP": fake_ipv4,
-        "X-Real-IP": fake_ipv4
+        if proxy.type == "http" or proxy.type == "https":
+            response = session.get(view_url, headers=headers, proxies={"http": f"http://{proxy.ip}:{proxy.port}", "https": f"https://{proxy.ip}:{proxy.port}"})
+
+        driver.get(view_url)
+
+        try:
+            not_now = WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, 'mt3GC')))
+            a = not_now.find_elements(By.TAG_NAME, "button")[1]
+            actions = ActionChains(driver)
+            actions.click(a)
+            actions.perform()
+        except:
+            pass
+
+        time.sleep(rand(10, 20))
+    except Exception as e:
+        pass
+    finally:
+        driver.quit()
+
+def simulate_twitch_view(video_id: str, proxy: Proxy, session: requests.Session):
+    webdriver.DesiredCapabilities.CHROME['proxy'] = {
+        "httpProxy": f"{proxy.ip}:{proxy.port}",
+        "ftpProxy": f"{proxy.ip}:{proxy.port}",
+        "sslProxy": f"{proxy.ip}:{proxy.port}",
+        "proxyType": "MANUAL",
     }
+    options = webdriver.ChromeOptions()
+    options.add_argument("--headless")
+    options.add_argument("--disable-blink-features=AutomationControlled")
+    options.add_argument("--disable-popup-blocking")
+    options.add_argument("--disable-infobars")
+    options.add_argument("--disable-web-security")
+    options.add_argument("--ignore-certificate-errors")
+    options.add_argument("--disable-notifications")
+    options.add_argument("--disable-extensions")
+    options.add_argument("--disable-gpu")
+    options.add_argument("--no-sandbox")
+    options.add_argument("--disable-dev-shm-usage")
+    options.add_argument("--mute-audio")
+    options.add_argument('--ignore-ssl-errors=yes')
+    options.add_argument('--ignore-certificate-errors')
+    driver = webdriver.Chrome(ChromeDriverManager().install(), options=options)
+
     try:
+        fake = Faker()
+        fake_ipv4 = fake.ipv4()
+        headers = {
+            "User-Agent": fake.user_agent(),
+            "X-Forwarded-For": fake_ipv4,
+            "Client-IP": fake_ipv4,
+            "X-Real-IP": fake_ipv4
+        }
         view_url = f"https://www.twitch.tv/videos/{video_id}"
-        response = session.get(view_url, headers=headers, proxies=proxies)
-        embed_link = f"https://player.twitch.tv/?video=v{video_id}&parent=www.example.com&autoplay=true&muted=false"
-        embed_link_with_start = f"{embed_link}&start={rand(4, 8)}"
-        print(embed_link_with_start)
-    except Exception as e:
-        print(f"Error in simulate_twitch_view: {e}")
 
-def simulate_spotify_view(video_id: str, proxy: str, session: requests.Session):
-    proxies = {
-        "http": f"http://{proxy}"
-    }
-    fake = Faker()
-    fake_ipv4 = fake.ipv4()
-    headers = {
-        "User-Agent": fake.user_agent(),
-        "X-Forwarded-For": fake_ipv4,
-        "Client-IP": fake_ipv4,
-        "X-Real-IP": fake_ipv4
+        if proxy.type == "http" or proxy.type == "https":
+            response = session.get(view_url, headers=headers, proxies={"http": f"http://{proxy.ip}:{proxy.port}", "https": f"https://{proxy.ip}:{proxy.port}"})
+
+        driver.get(view_url)
+
+        try:
+            not_now = WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, 'mt3GC')))
+            a = not_now.find_elements(By.TAG_NAME, "button")[1]
+            actions = ActionChains(driver)
+            actions.click(a)
+            actions.perform()
+        except:
+            pass
+
+        time.sleep(rand(10, 20))
+    except Exception as e:
+        pass
+    finally:
+        driver.quit()
+
+def simulate_spotify_view(video_id: str, proxy: Proxy, session: requests.Session):
+    webdriver.DesiredCapabilities.CHROME['proxy'] = {
+        "httpProxy": f"{proxy.ip}:{proxy.port}",
+        "ftpProxy": f"{proxy.ip}:{proxy.port}",
+        "sslProxy": f"{proxy.ip}:{proxy.port}",
+        "proxyType": "MANUAL",
     }
+    options = webdriver.ChromeOptions()
+    options.add_argument("--headless")
+    options.add_argument("--disable-blink-features=AutomationControlled")
+    options.add_argument("--disable-popup-blocking")
+    options.add_argument("--disable-infobars")
+    options.add_argument("--disable-web-security")
+    options.add_argument("--ignore-certificate-errors")
+    options.add_argument("--disable-notifications")
+    options.add_argument("--disable-extensions")
+    options.add_argument("--disable-gpu")
+    options.add_argument("--no-sandbox")
+    options.add_argument("--disable-dev-shm-usage")
+    options.add_argument("--mute-audio")
+    options.add_argument('--ignore-ssl-errors=yes')
+    options.add_argument('--ignore-certificate-errors')
+    driver = webdriver.Chrome(ChromeDriverManager().install(), options=options)
+
     try:
+        fake = Faker()
+        fake_ipv4 = fake.ipv4()
+        headers = {
+            "User-Agent": fake.user_agent(),
+            "X-Forwarded-For": fake_ipv4,
+            "Client-IP": fake_ipv4,
+            "X-Real-IP": fake_ipv4
+        }
         view_url = f"https://open.spotify.com/track/{video_id}"
-        response = session.get(view_url, headers=headers, proxies=proxies)
-        embed_link = f"https://open.spotify.com/embed/track/{video_id}?autoplay=true"
-        embed_link_with_start = f"{embed_link}?start={rand(4, 8)}"
-        print(embed_link_with_start)
+
+        if proxy.type == "http" or proxy.type == "https":
+            response = session.get(view_url, headers=headers, proxies={"http": f"http://{proxy.ip}:{proxy.port}", "https": f"https://{proxy.ip}:{proxy.port}"})
+
+        driver.get(view_url)
+
+        try:
+            not_now = WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, 'mt3GC')))
+            a = not_now.find_elements(By.TAG_NAME, "button")[1]
+            actions = ActionChains(driver)
+            actions.click(a)
+            actions.perform()
+        except:
+            pass
+
+        time.sleep(rand(10, 20))
     except Exception as e:
-        print(f"Error in simulate_spotify_view: {e}")
+        pass
+    finally:
+        driver.quit()
 
 def simulate_views(url: str, platform: str, count: int, delay: int, parallel_processes: int, session: requests.Session):
     video_id = extract_video_id(url, platform)
     proxy = get_random_proxy()
-    
     if not proxy:
-        print("No proxy available.")
         return
-
-    for _ in tqdm(range(count), desc=f"Simulating views for {url}"):
-        if platform == "instagram":
-            simulate_instagram_view(video_id, proxy, session)
-        elif platform == "tiktok":
-            simulate_tiktok_view(video_id, proxy, session)
-        elif platform == "youtube":
-            simulate_youtube_view(video_id, proxy, session)
-        elif platform == "facebook":
-            simulate_facebook_view(video_id, proxy, session)
-        elif platform == "twitch":
-            simulate_twitch_view(video_id, proxy, session)
-        elif platform == "spotify":
-            simulate_spotify_view(video_id, proxy, session)
+    for _ in range(count):
+        try:
+            if platform == "instagram":
+                simulate_instagram_view(video_id, proxy, session)
+            elif platform == "tiktok":
+                simulate_tiktok_view(video_id, proxy, session)
+            elif platform == "youtube":
+                simulate_youtube_view(video_id, proxy, session)
+            elif platform == "facebook":
+                simulate_facebook_view(video_id, proxy, session)
+            elif platform == "twitch":
+                simulate_twitch_view(video_id, proxy, session)
+            elif platform == "spotify":
+                simulate_spotify_view(video_id, proxy, session)
+        except Exception as e:
+            pass
 
 @app.post("/simulate_views")
 async def simulate_views_endpoint(request: VisitRequest):
@@ -412,10 +602,8 @@ async def simulate(urls: str = Form(...), platform: str = Form(...), count: int
             for index, url in enumerate(urls.split("\n")):
                 try:
                     simulate_views(url, platform, count, delay, parallel_processes, session)
-                    print(f"Simulation started for URL {index+1}: {url}")
                 except Exception as e:
-                    print(f"Error processing URL {index+1}: {e}")
-            
+                    pass
             return PlainTextResponse("Simulation completed.")
         else:
             return PlainTextResponse("Credentials not found for this platform.")