代理設置
住宅代理

流量餘額 超出使用截止時間,帳戶內餘額將會進行凍結;
再次購買後,之前未使用的凍結流量會自動解封,並與最新購買的流量合併延遲至最新截止日期

0MB充電後,過期的流量將被激活。

選擇國家

    查看國家代碼

    選擇城市

      認證帳戶

      主機名:端口

        IP模式

        粘性IP
        • 粘性IP
        • Randomize IP

        IP持續時間

        +

        輸入錯誤

        (1-60分鐘)

        用戶名

        密碼

        測試命令:
        複製
        測試命令:

        *僅支持在非中國大陸環境下使用。

        hostname:port:username:password
        • hostname:port:username:password
        • username:password:hostname:port
        • username:password@hostname:port
        10
        • 1
        • 10
        • 50
        • 100
        • 500
        產生
        測試命令:
        複製
        測試命令:

        快速開始

        ParameterDescribe

        CountryFilter the country where the required IP is located

        StateScreen the state or province where the required IP is located

        CityFilter the city where the required IP is located

        Hostname:portHost name and port, assigned by default

        UsernameAssigned by default according to the user's login account

        PasswordBy default, a password composed of letters and numbers is generated, which supports user modification

        用例

        C/C++
        Go
        Node.js
        Php
        JAVA
        Python
        #include iostream
        #include stdio.h
        #include string
        #include Windows.h
        #include "curl/curl.h"
        #pragma comment(lib, "libcurl.lib")
        using namespace std;
        
        static size_t write_buff_data(char* buffer, size_t size, size_t nitems, void* outstream)
        {//Copy the received data to the cache
        memcpy(outstream, buffer, nitems * size);
        return nitems * size;
        }
        /*
        Use HTTP proxy
        */
        int GetUrlHTTP(char* url, char* buff)
        {
        CURL* curl;
        CURLcode res;
        curl = curl_easy_init();
        if (curl)
        {
            curl_easy_setopt(curl, CURLOPT_PROXY, "http://ip:port");//Set HTTP proxy address
            curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, "User name: password");//Proxy username password
            curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)buff);//Set Read-Write Cache
            curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_buff_data);//Set Callback Function
            curl_easy_setopt(curl, CURLOPT_URL, url);//Set URL address
            curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, 10L);//Sets a long integer to control how many seconds CURLOPT_LOW_SPEED_LIMIT bytes are passed
            curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 50L);//Set a long integer to control how many bytes are transferred
            curl_easy_setopt(curl, CURLOPT_MAX_RECV_SPEED_LARGE, 2000000L);//Maximum download speed
        
            res = curl_easy_perform(curl);
            curl_easy_cleanup(curl);
            if (res == CURLE_OK) {
                return res;
            }
            else {
                printf("error code:%d\n", res);
                MessageBox(NULL, TEXT("Get IP Error"), TEXT("assistant"), MB_ICONINFORMATION | MB_YESNO);
            }
        }
        return res;
        }
        
        package main
                          package main
            
                          import (
                              "context"
                              "fmt"
                              "golang.org/x/net/proxy"
                              "io/ioutil"
                              "net"
                              "net/http"
                              "net/url"
                              "strings"
                              "time"
                          )
                          
                          var testApi = "https://api.ipify.org/?format=json"
                          
                          func main() {
                              var proxyIP = "asg.360s5.com:3500"
                              var username = "xxx-zone-isp"
                              var password = ""
                              httpProxy(proxyIP, username, password)
                              time.Sleep(time.Second * 1)
                              Socks5Proxy(proxyIP, username, password)
                          
                          }
                          func httpProxy(proxyUrl, user, pass string) {
                              defer func() {
                                  if err := recover(); err != nil {
                                      fmt.Println(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("http result = ", response.Status, string(body))
                          
                              return
                          }
                          
                          func Socks5Proxy(proxyUrl, user, pass string) {
                          
                              defer func() {
                                  if err := recover(); err != nil {
                                      fmt.Println(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("socks5 result = ",string(body))
                              }
                          }
        
        const SocksProxyAgent = require("socks-proxy-agent");
        const net = require("net");
        const proxyHost = "proxy-server-hostname";
        const proxyPort = 1080;
        const proxyUsername = "your-username";
        const proxyPassword = "your-password";
        const agent = new SocksProxyAgent({
        host: proxyHost,
        port: proxyPort,
        auth: `${proxyUsername}:${proxyPassword}`
        });
        const socket = net.connect({
        host: "destination-hostname",
        port: 80,
        agent
        });
        socket.on("connect", () => {
        console.log("Connected to destination server through SOCKS5 proxy.");
        });
        socket.on("error", err => {
        console.error("Error:", err);
        });
        <?php
        $targetUrl = "https://www.google.com/";
        $proxyServer = "http://asg.360s5.com:3500";
        $proxyUserPwd = "user:psswd";
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $targetUrl);
        curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, false);
        curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
        curl_setopt($ch, CURLOPT_PROXYTYPE, 0); //http
        // curl_setopt($ch, CURLOPT_PROXYTYPE, 5); //sock5
        curl_setopt($ch, CURLOPT_PROXY, $proxyServer);
        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);
        curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxyUserPwd);
        $result = curl_exec($ch);
        $err = curl_error($ch);
        curl_close($ch);
        var_dump($err);
        var_dump($result);
        ?>
        package demo;
        import okhttp3.Credentials;
        import okhttp3.OkHttpClient;
        import okhttp3.Request;
        
        import java.io.IOException;
        import java.net.InetSocketAddress;
        import java.net.PasswordAuthentication;
        import java.net.Proxy;
        
        /**
        * compile 'com.squareup.okhttp3:okhttp:3.10.0'
        */
        class AutProxyJava {
        public static void main(String[] args) throws IOException {
            testWithOkHttp();
        
            testSocks5WithOkHttp();
        }
        
        public static void testWithOkHttp() throws IOException {
            String url = "https://api.ipify.org?format=json";
            Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("asg.360s5.com", 3600));
            OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).proxyAuthenticator((route, response) -> {
                String credential = Credentials.basic("username-zone-custom", password);
                    return response.request().newBuilder()
                .header("Proxy-Authorization", credential).build();
            }).build();
        
        
            Request request = new Request.Builder().url(url).build();
            okhttp3.Response response = client.newCall(request).execute();
            String responseString = response.body().string();
            System.out.println(responseString);
        }
        
        public static void testSocks5WithOkHttp() throws IOException {
            String url = "https://api.ipify.org?format=json";
            Proxy proxy = new Proxy(Proxy.Type.SOCKS, new InetSocketAddress("asg.360s5.com", 3600));
            java.net.Authenticator.setDefault(new java.net.Authenticator() {
                private PasswordAuthentication authentication =
                new PasswordAuthentication("laylay-zone-isp", "123456".toCharArray());
        
                @Override
                protected PasswordAuthentication getPasswordAuthentication() {
                    return authentication;
                }
            });
            OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).build();
        
            Request request = new Request.Builder().url(url).build();
            okhttp3.Response response = client.newCall(request).execute();
            String responseString = response.body().string();
            System.out.println(responseString);
        }
        }
        import urllib
        import socks
        import http.client
        from urllib.error import URLError
        import ssl
        from urllib.request import build_opener, HTTPHandler, HTTPSHandler
        
        
        def merge_dict(a, b):
        d = a.copy()
        d.update(b)
        return d
        
        
        class SocksiPyConnection(http.client.HTTPConnection):
        def __init__(self, proxytype, proxyaddr, proxyport=None, rdns=True, username=None, password=None, *args, **kwargs):
            self.proxyargs = (proxytype, proxyaddr, proxyport, rdns, username, password)
            http.client.HTTPConnection.__init__(self, *args, **kwargs)
        
        def connect(self):
            self.sock = socks.socksocket()
            self.sock.setproxy(*self.proxyargs)
            if type(self.timeout) in (int, float):
                self.sock.settimeout(self.timeout)
            self.sock.connect((self.host, self.port))
        
        
        class SocksiPyConnectionS(http.client.HTTPSConnection):
        def __init__(self, proxytype, proxyaddr, proxyport=None, rdns=True, username=None, password=None, *args, **kwargs):
            self.proxyargs = (proxytype, proxyaddr, proxyport, rdns, username, password)
            http.client.HTTPSConnection.__init__(self, *args, **kwargs)
        
        def connect(self):
            sock = socks.socksocket()
            sock.setproxy(*self.proxyargs)
            if type(self.timeout) in (int, float):
                sock.settimeout(self.timeout)
            sock.connect((self.host, self.port))
            self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file)
        
        
        class SocksiPyHandler(HTTPHandler, HTTPSHandler):
        def __init__(self, *args, **kwargs):
            self.args = args
            self.kw = kwargs
            HTTPHandler.__init__(self)
        
        def http_open(self, req):
            def build(host, port=None, timeout=0, **kwargs):
                kw = merge_dict(self.kw, kwargs)
                conn = SocksiPyConnection(*self.args, host=host, port=port, timeout=timeout, **kw)
                return conn
        
            return self.do_open(build, req)
        
        def https_open(self, req):
            def build(host, port=None, timeout=0, **kwargs):
                kw = merge_dict(self.kw, kwargs)
                conn = SocksiPyConnectionS(*self.args, host=host, port=port, timeout=timeout, **kw)
                return conn
        
            return self.do_open(build, req)
        
        
        username = ""
        password = ""
        ip = "asg.360s5.com"
        port = 3600
        proxy = "socks5://{username}:{password}@{ip}:{port}".format(username=username, password=password, ip=ip, port=port)
        # socks.set_default_proxy(socks.SOCKS5, ip, port,username=username,password=password)
        # socket.socket = socks.socksocket
        
        url = 'https://www.google.com/'
        
        try:
        req = urllib.request.Request(url=url, headers={'User-Agent':'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36'})
        opener = build_opener(SocksiPyHandler(socks.SOCKS5, ip, port, username=username, password=password))
        response = opener.open(req)
        # response = urllib.request.urlopen(req)
        # response = request.urlopen(url)
        print(response.read().decode('utf-8'))
        except URLError as e:
        print(e)
        直接下載

        登錄

        註冊

        使用360Proxy發展您的業務

        立即使用

        如有問題,请通过[email protected]聯係我們。