package main

        import (
          "context"
          "fmt"
          "io/ioutil"
          "net"
          "net/http"
          "net/url"
          "strings"
          "time"
        
          "golang.org/x/net/proxy"
        )
        
        // Proxy setting
        var ip = "proxy server"   //Example:192.168.0.1
        var port = "port" //Example:2333
        // Proxy server
        var proxyServer = "http://" + ip + ":" + port
        
        // Test link
        var testApi = "https://ipinfo.pyproxy.io"
        
        func main() {
          var proxyIP = proxyServer
          go httpProxy(proxyIP, "", "")
          go Socks5Proxy(proxyIP, "", "")
          time.Sleep(time.Minute)
        }
        
        // http proxy
        func httpProxy(proxyUrl, user, pass string) {
          defer func() {
            if err := recover(); err != nil {
              fmt.Println(time.Now().Format("2006-01-02 15:04:05 07"), "http", "response:", err)
            }
          }()
          urli := url.URL{}
        
          if !strings.Contains(proxyUrl, "http") {
            proxyUrl = fmt.Sprintf("http://%s", proxyUrl)
          }
        
          urlProxy, _ := urli.Parse(proxyUrl)
          if user != "" && pass != "" {
            urlProxy.User = url.UserPassword(user, pass)
          }
        
          client := &http.Client{
            Transport: &http.Transport{
              Proxy: http.ProxyURL(urlProxy),
            },
          }
          rqt, err := http.NewRequest("GET", testApi, nil)
          if err != nil {
            panic(err)
            return
          }
          response, err := client.Do(rqt)
          if err != nil {
            panic(err)
            return
          }
        
          defer response.Body.Close()
          body, _ := ioutil.ReadAll(response.Body)
          fmt.Println(time.Now().Format("2006-01-02 15:04:05 07"), proxyUrl, "[http success]", "response:", response.Status, string(body))
        
          return
        }
        
        // socks5 proxy
        func Socks5Proxy(proxyUrl, user, pass string) {
        
          defer func() {
            if err := recover(); err != nil {
              fmt.Println(time.Now().Format("2006-01-02 15:04:05 07"), proxyUrl, "response:", err)
            }
          }()
        
          var userAuth proxy.Auth
          if user != "" && pass != "" {
            userAuth.User = user
            userAuth.Password = pass
          }
          dialer, err := proxy.SOCKS5("tcp", proxyUrl, &userAuth, proxy.Direct)
          if err != nil {
            panic(err)
          }
          httpClient := &http.Client{
            Transport: &http.Transport{
              DialContext: func(ctx context.Context, network, addr string) (conn net.Conn, err error) {
                return dialer.Dial(network, addr)
              },
            },
            Timeout: time.Second * 10,
          }
        
          if resp, err := httpClient.Get(testApi); err != nil {
            panic(err)
          } else {
            defer resp.Body.Close()
            body, _ := ioutil.ReadAll(resp.Body)
            fmt.Println(time.Now().Format("2006-01-02 15:04:05 07"), proxyUrl, "[socks5 success]", "response:", string(body))
          }
        }                          
                        
                    

                        
        #!/usr/bin/env node
        require('request-promise')({
            url: 'https://pyproxy.com',//Request URL
            proxy: 'http://ip:port',//Proxy server IP: port
            })
        .then(function(data){ console.log(data); },
            function(err){ console.error(err); });
                        
                    

                        
        <?php
    
          //Proxy setting
          $ip = "Proxy server IP";//Example:192.168.0.1
          $port = "Port(Port)";//Example:2333
          // Target URL
          $targetUrl = "http://google.com";
          // Proxy server
          $proxyServer = "http://$ip:$port";
      
            // Tunnel verification
          $ch = curl_init();
          curl_setopt($ch, CURLOPT_URL, $targetUrl);
          curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, false);
          curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);

          // Proxy server setting
          curl_setopt($ch, CURLOPT_PROXYTYPE, 0); //http
          // curl_setopt($ch, CURLOPT_PROXYTYPE, 5); //sock5
          curl_setopt($ch, CURLOPT_PROXY, $proxyServer);

          // Tunnel verification setting
          curl_setopt($ch, CURLOPT_PROXYAUTH, CURLAUTH_BASIC);
          curl_setopt($ch, CURLOPT_USERAGENT, "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727;)");
          curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 3);
          curl_setopt($ch, CURLOPT_TIMEOUT, 5);
          curl_setopt($ch, CURLOPT_HEADER, true);
          curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
          $result = curl_exec($ch);
          $err = curl_error($ch);

          curl_close($ch);

          var_dump($err);
          var_dump($result);
                        
                    

                        
        package demo;

        import okhttp3.OkHttpClient;
        import okhttp3.Request;
        
        import java.io.IOException;
        import java.net.InetSocketAddress;
        import java.net.Proxy;
        
        /**
          * compile 'com.squareup.okhttp3:okhttp:4.9.3'
          */
        class ApiProxyJava {
            public static void main(String[] args) throws IOException {
                testHttpWithOkHttp();
                testSocks5WithOkHttp();
            }
        
            /**
              * HTTP proxy (http proxy)
              */
            public static void testHttpWithOkHttp() throws IOException {
                //Set the URL you want to visit
                String url = "https://ipinfo.pyproxy.io";
                //Create an HTTP proxy object and set IP and port for the proxy server
                Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("ip", "port"));//The "ip" and "port" here should be replaced with proxy server IP and port.
                //Build an OkHttpClient instance and configure the HTTP proxy
                OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).build();
                //Send GET Request and get response
                Request request = new Request.Builder().url(url).build();
                okhttp3.Response response = client.newCall(request).execute();
                //Get and print response
                String responseString = response.body().string();
                System.out.println(responseString);
            }
        
            /**
              * SOCKS5 Proxy
              */
            public static void testSocks5WithOkHttp() throws IOException {
                //Set the URL you want to visit
                String url = "https://ipinfo.pyproxy.io";
                //Create a SOCKS proxy object and set IP and port for the proxy server
                Proxy proxy = new Proxy(Proxy.Type.SOCKS, new InetSocketAddress("ip", "port"));//The "ip" and "port" here should be replaced with proxy server IP and port.
                //Build an OkHttpClient instance and configure the SOCKS proxy
                //A SOCKS proxy is used here, which means that all network traffic (including TCP connections) will be forwarded through this SOCKS proxy.
                OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).build();
                //Send GET Request and get response
                Request request = new Request.Builder().url(url).build();
                okhttp3.Response response = client.newCall(request).execute();
                //Get and print response
                String responseString = response.body().string();
                System.out.println(responseString);
            }
        }           
                        
                    

                        
        # coding=utf-8
        # !/usr/bin/env python
        import json
        import threading
        import time
        import requests as rq
        
        # Set head of request
        headers = {
            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:85.0) Gecko/20100101 Firefox/85.0",
            "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
            "Accept-Language": "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2",
            "Accept-Encoding": "gzip, deflate, br"
        }
        # Test URL
        testUrl = 'https://ipinfo.pyproxy.io'
        
        
        # Main business
        def testPost(host, port):
            # Configure IP and port you get
            proxies = {
                # Proxy server IP you get by API
                # Port you get by API
                'http': 'http://{}:{}'.format(host, port),
                'https': 'http://{}:{}'.format(host, port),
            }
            while True:
                try:
                    # Test after configuring proxies
                    res = rq.get(testUrl, proxies=proxies, timeout=5)
                    # print(res.status_code)
                    # Print the result of request
                    print(res.status_code, "***", res.text)
                    break
                except Exception as e:
                    print(e)
                    break
            return
        
        
        class ThreadFactory(threading.Thread):
            def __init__(self, host, port):
                threading.Thread.__init__(self)
                self.host = host
                self.port = port
        
            def run(self):
                testPost(self.host, self.port)
        
        
        # Link for getting proxies  Return is in json type
        tiqu = 'Extract the link'(Get proxy link)
        
        while 1 == 1:
            # Get 10 at a time, and put in thread
            resp = rq.get(url=tiqu, timeout=5)
            try:
                if resp.status_code == 200:
                    dataBean = json.loads(resp.text)
                else:
                    print("Fail to get")
                    time.sleep(1)
                    continue
            except ValueError:
                print("fail to get")
                time.sleep(1)
                continue
            else:
                # Parse json array and get ip and port
                print("code=", dataBean["code"])
                code = dataBean["code"]
                if code == 0:
                    threads = []
                    for proxy in dataBean["data"]:
                        threads.append(ThreadFactory(proxy["ip"], proxy["port"]))
                    for t in threads:  # Turn on thread
                        t.start()
                        time.sleep(0.01)
                    for t in threads:  # Block thread
                        t.join()
            # break
            time.sleep(1)