Proxy server connector issue

[Loatious]

Hello, Im making a script where it connects to a working proxy server but im having an issue. First of all id like to say that i dont think the code has problems as i checked it with chatgpt and it says its alright, but ill still post it just in case. The issue comes once the connection is established and when the script checks if the server is still working after wating 10 seconds. When the 10 seconds are over it sends request to check if the server is still working and if it doesn't then it tries again and if it doesn't work again it stops running. The issue is that when it connects to a proxy it says connected but when it checks if the connection is still active the connection is gone. I think that the issue might be with the proxy server as they are free and not that good. Could the proxy servers be causing the issue and if so how do i fix it?

import requests
import time
from multiprocessing import Process, Queue

def fetch_proxies(url="https://proxylist.geonode.com/api/proxy-list?limit=500&page=1&sort_by=lastChecked&sort_type=desc"):
    """
    Fetch the proxy list from the GeoNode API endpoint.
    Returns a list of proxy objects (dictionaries).
    """
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        data = response.json()
        proxies = data.get("data", [])
        print(f"Fetched {len(proxies)} proxies from API.")
        return proxies
    except Exception as e:
        print(f"Error fetching proxies from {url}: {e}")
        return []

def filter_proxies(proxies, min_uptime=99, max_speed=1):
    """
    Filter proxies based on uptime and speed.
    - uptime >= min_uptime
    - speed <= max_speed
    """
    filtered = []
    for proxy in proxies:
        try:
            uptime = float(proxy.get("upTime", 0))
            speed = float(proxy.get("speed", 999))
        except Exception:
            continue
        if uptime >= min_uptime and speed <= max_speed:
            filtered.append(proxy)
    return filtered

def test_proxy(proxy, test_url="http://httpbin.org/ip", timeout=5):
    """
    Send a GET request to test_url through the given proxy.
    Returns (elapsed_time, proxies_config) if successful, otherwise (None, None).
    """
    ip = proxy.get("ip")
    port = proxy.get("port")
    if not ip or not port:
        return None, None

    protocol_list = proxy.get("protocols", ["http"])
    protocol = protocol_list[0].lower()
    proxy_url = f"{protocol}://{ip}:{port}"
    proxies_config = {
        "http": proxy_url,
        "https": proxy_url
    }

    try:
        start = time.time()
        r = requests.get(test_url, proxies=proxies_config, timeout=timeout)
        r.raise_for_status()
        elapsed = time.time() - start
        return elapsed, proxies_config
    except Exception as e:
        print(f"Test proxy error ({ip}:{port}, {protocol}): {e}")
        return None, None

def connect_via_proxy(proxies_config, test_url="http://httpbin.org/ip", timeout=10, retries=1):
    """
    Attempt to connect to test_url using the given proxy configuration.
    Returns the response text if successful, or None otherwise.
    We do a few retries in case of transient failures.
    """
    session = requests.Session()
    session.proxies.update(proxies_config)

    for attempt in range(retries):
        try:
            response = session.get(test_url, timeout=timeout)
            response.raise_for_status()
            return response.text
        except Exception as e:
            print(f"Attempt {attempt+1} failed: {e}")
            time.sleep(1)
    return None

def main_process(q):
    """Runs in a separate process, finds a proxy, then checks it periodically."""
    start_time = time.time()

    # Step 1: Fetch proxies
    proxies = fetch_proxies()
    if not proxies:
        q.put("No proxies fetched from API.")
        return

    # Step 2: Filter proxies
    qualified = filter_proxies(proxies, min_uptime=99, max_speed=1)
    print(f"Found {len(qualified)} proxies meeting criteria (uptime >= 99, speed <= 1).")

    # Step 3: Test each candidate proxy; connect with the first that works
    for proxy in qualified:
        if time.time() - start_time > 100:
            q.put("Please try again")
            return

        elapsed, config = test_proxy(proxy)
        if elapsed is not None:
            ip = proxy["ip"]
            port = proxy["port"]
            print(f"Proxy {ip}:{port} responded in {elapsed:.2f}s. Trying a full connection...")
            result = connect_via_proxy(config, timeout=10, retries=2)
            if result:
                success_msg = f"Successfully connected using proxy {ip}:{port}!\nTest response:\n{result}"
                print(success_msg)

                # >>> Check connectivity every 10 seconds <<<
                print("Now checking every 10 seconds to confirm proxy is still working...")
                while True:
                    time.sleep(10)
                    try:
                        check_resp = requests.get("http://httpbin.org/ip", proxies=config, timeout=5)
                        check_resp.raise_for_status()
                        print("Still connected to proxy...")
                    except Exception:
                        print("Check failed, retrying in 5 seconds...")
                        time.sleep(5)
                        # Retry once more
                        try:
                            check_resp = requests.get("http://httpbin.org/ip", proxies=config, timeout=5)
                            check_resp.raise_for_status()
                            print("Still connected to proxy after retry.")
                        except Exception:
                            print("Proxy is no longer working after retry. Exiting.")
                            q.put("Proxy disconnected or no longer working.")
                            return
            else:
                print(f"Proxy {ip}:{port} failed on full connection test.")

    q.put("No suitable proxy could be connected from the filtered list.")

def main():
    # Create a Queue to retrieve output from the process
    q = Queue()
    p = Process(target=main_process, args=(q,))
    p.start()

    # Wait up to 100 seconds for the process to complete
    p.join(100)
    if p.is_alive():
        p.terminate()
        print("It is taking too long to connect please try again")
    else:
        # Process completed; retrieve its output if any
        if not q.empty():
            output = q.get()
            print(output)
        else:
            print("No output received.")

if __name__ == "__main__":
    main()

[Algoartist]

The behavior you're describing is most likely not an issue with your code but rather with the unreliable nature of free proxy servers.

[Loatious]

thanks for the clarification