Việt Nam

Proxies Cao Cấp

Name: Mua Proxy Cao Cấp - Chỉ từ $0,65/GB
Brand: Thordata
Rating: 4.8 (3678 reviews)

Sử dụng proxies cao cấp với mức độ bảo mật và quyền riêng tư cao nhất để vượt qua hạn chế địa lý và thực hiện các tác vụ nhạy cảm yêu cầu ẩn danh cao, chẳng hạn như thu thập dữ liệu và quản lý tài khoản mạng xã hội.

Hơn 100M+ địa chỉ IP Proxy

Proxies Residential, Datacenter và ISP

Thời gian hoạt động 99,9%

Nhắm mục tiêu theo Quốc gia, Thành phố, Tiểu bang và ASN

Gói đăng ký minh bạch

Dùng thử miễn phí

Khám phá các loại proxy cao cấp

Phổ biến nhất

Residential Proxies

Hơn 190 địa điểm toàn cầu

Thời gian phản hồi trung bình <0.5 giây

Phiên quay vòng và phiên cố định

Hỗ trợ

Thời gian IP kéo dài 90 phút

Bắt đầu từ

$0.75 /GB

Dùng thử miễn phí 

Mobile Proxies

IP mạng di động 4G/5G thật

Mạng di động bản địa

Hỗ trợ HTTP(S)

Ẩn danh và độ tin cậy cao

Khả năng định vị địa lý mạnh mẽ

Bắt đầu từ

$2.20 /GB

Dùng thử miễn phí 

Static ISP Proxies

Proxy chuyên dụng

Hỗ trợ

Lưu lượng không giới hạn

Các nhà cung cấp ISP cao cấp

Thời gian hoạt động 99.9%

Bắt đầu từ

$1.50 /IP

Dùng thử miễn phí 

Datacenter Proxies

Proxy chuyên dụng, tính phí theo IP

Mạng lưới 650K+ Proxy

Nhắm mục tiêu cấp thành phố miễn phí

Lưu lượng và phiên không giới hạn

Hiệu quả chi phí cao

Bắt đầu từ

$1.50 /IP

Dùng thử miễn phí 

Địa điểm proxy tinh hoa phổ biến nhất

Thúc đẩy các dự án của bạn bằng cách sử dụng proxy tinh hoa từ bất kỳ quốc gia hoặc thành phố nào trên toàn thế giới.

 Residential IPs

 Mobile IPs

 ISP IPs

 Datacenter IPs

Hoa Kỳ

5,604,857 IPs



Vương quốc Anh

1,910,532 IPs



Đức

1,385,182 IPs



Canada

1,048,605 IPs



Pháp

1,265,354 IPs



Hà Lan

386,796 IPs



Úc

453,859 IPs



Nhật Bản

612,248 IPs



Xem tất cả vị trí

Chọn proxy cao cấp có hiệu suất cao nhất

Proxy cao cấp cung cấp mức độ ẩn danh và bảo vệ quyền riêng tư cao nhất. Chúng ẩn địa chỉ IP thực của bạn một cách hiệu quả và không tiết lộ việc sử dụng proxy, giúp hoạt động trực tuyến của bạn an toàn hơn. Proxy cao cấp có độ ổn định và tốc độ cao hơn, phù hợp cho việc thu thập dữ liệu, nghiên cứu thị trường hoặc các tác vụ nhạy cảm khác yêu cầu mức độ ẩn danh cao.

Dùng thử miễn phí



          
          import requests
        
          username = "USERNAME"
        
          password = "PASSWORD"
        
          proxy = "user.pr.zytedata.com:9999"
        
          proxies = {
        
              'http': f'http://{username}:{password}@{proxy}',
        
              'https': f'http://{username}:{password}@{proxy}'
        
          }
        
          response = requests.request(
        
              'GET',
        
              'https://ipinfo.zytedata.com',
        
              proxies=proxies,
        
          )
        
          print(response.text)
        
          import requests
        
          username = "USERNAME"
        
          password = "PASSWORD"
        
          proxy = "IP:PORT"
        
          proxies = {
        
              'http': f'http://{username}:{password}@{proxy}',
        
              'https': f'http://{username}:{password}@{proxy}'
        
          }
        
          response = requests.request(
        
              'GET',
        
              'https://ipinfo.zytedata.com',
        
              proxies=proxies,
        
          )
        
          print(response.text)
        
          import requests
        
          username = "USERNAME"
        
          password = "PASSWORD"
        
          proxy = "IP:PORT"
        
          proxies = {
        
              'http': f'http://{username}:{password}@{proxy}',
        
              'https': f'http://{username}:{password}@{proxy}'
        
          }
        
          response = requests.request(
        
              'GET',
        
              'https://ipinfo.zytedata.com',
        
              proxies=proxies,
        
          )
        
          print(response.text)
        
          import requests
        
          username = "USERNAME"
        
          password = "PASSWORD"
        
          proxy = "unlimited.zytedata.com:9999"
        
          proxies = {
        
              'http': f'http://{username}:{password}@{proxy}',
        
              'https': f'http://{username}:{password}@{proxy}'
        
          }
        
          response = requests.request(
        
              'GET',
        
              'https://ipinfo.zytedata.com',
        
              proxies=proxies,
        
          )
        
          print(response.text)
        
          import requests
        
          username = "USERNAME"
        
          password = "PASSWORD"
        
          proxy = "user.pr.zytedata.com:5555"
        
          proxies = {
        
              'http': f'http://{username}:{password}@{proxy}',
        
              'https': f'http://{username}:{password}@{proxy}'
        
          }
        
          response = requests.request(
        
              'GET',
        
              'https://ipinfo.zytedata.com',
        
              proxies=proxies,
        
          )
        
          print(response.text)
        
          import requests
        
          import json
        
          def main():
        
            client = requests.Session()
        
            target_url = "https://scraperapi.zytedata.com/builder"
        
            spider_parameters = [
        
              {
        
                "url": "https://www.youtube.com/@stephcurry/videos",
        
                "order_by": "",
        
                "num_of_posts": ""
        
              }
        
            ]
        
            spider_parameters_json = json.dumps(spider_parameters)
        
            form_data = {
        
              "spider_name": "youtube.com",
        
              "spider_id": "youtube_video-post_by-url",
        
              "spider_parameters": spider_parameters_json,
        
              "spider_errors": "true",
        
              "file_name": "{{VideoID}}"
        
            }
        
            headers = {
        
              "Authorization": "Bearer Token",
        
              "Content-Type": "application/x-www-form-urlencoded"
        
            }
        
            try:
        
              resp = client.post(target_url, data=form_data, headers=headers)
        
              resp.raise_for_status()  # Raises an HTTPError for bad responses
        
              print(f"Status Code: {resp.status_code}")
        
              print(f"Response Body: {resp.text}")
        
            except requests.exceptions.RequestException as e:
        
              print(f"Error sending request: {e}")
        
          if __name__ == "__main__":
        
            main()
        
          import http.client
        
          from urllib.parse import urlencode
        
          conn = http.client.HTTPSConnection("webunlocker.zytedata.com")
        
          payload = {
        
              "url": "https://www.google.com",
        
              "type": "html",
        
              "js_render": "True"
        
          }
        
          form_data = urlencode(payload)
        
          headers = {
        
              'Authorization': "Bearer Token",
        
              'content-type': "application/x-www-form-urlencoded"
        
          }
        
          conn.request("POST", "/request", form_data, headers)
        
          res = conn.getresponse()
        
          data = res.read()
        
          print(f"Status: {res.status} {res.reason}")
        
          print(data.decode("utf-8"))
        
          import http.client 
        
          from urllib.parse import urlencode
        
          conn = http.client.HTTPSConnection("scraperapi.zytedata.com")
        
          params = {
        
                  "engine": "google",
        
                  "q": "pizza",
        
                  "json": "1"
        
                }
        
          payload = urlencode(params) 
        
          headers = { 
        
            'Authorization': 'Bearer Token',
        
            'Content-Type': 'application/x-www-form-urlencoded'
        
          }
        
          conn.request("POST", "/request", payload, headers) 
        
          res = conn.getresponse() 
        
          data = res.read() 
        
          print(data.decode("utf-8"))
        
          curl -x user.pr.zytedata.com:9999 -U "td-customer-USERNAME:PASSWORD" https://ipinfo.zytedata.com
        
          curl -x IP:PORT -U "td-customer-USERNAME:PASSWORD" https://ipinfo.zytedata.com
        
          curl -x IP:PORT -U "td-customer-USERNAME:PASSWORD" https://ipinfo.zytedata.com
        
          curl -x unlimited.zytedata.com:9999 -U "td-customer-USERNAME:PASSWORD" https://ipinfo.zytedata.com
        
          curl -x user.pr.zytedata.com:5555 -U "td-customer-USERNAME:PASSWORD" https://ipinfo.zytedata.com
        
          curl -X POST "https://scraperapi.zytedata.com/builder" \
        
            -H "Authorization: Bearer Token" \
        
            -H "Content-Type: application/x-www-form-urlencoded" \
        
            -d "spider_name=youtube.com" \
        
            -d "spider_id=youtube_video-post_by-url" \
        
            -d "spider_parameters=[{\"url\": \"https://www.youtube.com/@stephcurry/videos\",\"order_by\": \"\",\"num_of_posts\": \"\"}]" \
        
            -d "spider_errors=true" \
        
            -d "file_name={{VideoID}}"
        
          curl -X POST https://webunlocker.zytedata.com/request \
        
           -H "Authorization: Bearer Token" \
        
           -H "Content-Type: application/x-www-form-urlencoded" \
        
           -d "url=https://www.google.com" \
        
           -d "type=html" \
        
           -d "js_render=True"
        
          curl -X POST https://scraperapi.zytedata.com/request \
        
           -H "Content-Type: application/x-www-form-urlencoded" \
        
           -H "Authorization: Bearer Token" \
        
           -d "engine=google" \
        
           -d "q=pizza" \
        
           -d "json=1"
        
          import fetch from 'node-fetch';
        
          import createHttpsProxyAgent from 'https-proxy-agent';
        
          const username = 'td-customer-USERNAME';
        
          const password = 'PASS';
        
          const proxy = 'user.pr.zytedata.com:9999';
        
          const agent = createHttpsProxyAgent(
        
            `http://${username}:${password}@${proxy}`
        
          );
        
          const response = await fetch('https://ipinfo.zytedata.com', {
        
            method: 'get',
        
            agent: agent,
        
          });
        
          console.log(await response.text());
        
          import fetch from 'node-fetch';
        
          import createHttpsProxyAgent from 'https-proxy-agent';
        
          const username = 'td-customer-USERNAME';
        
          const password = 'PASS';
        
          const proxy = 'IP:PORT';
        
          const agent = createHttpsProxyAgent(
        
            `http://${username}:${password}@${proxy}`
        
          );
        
          const response = await fetch('https://ipinfo.zytedata.com', {
        
            method: 'get',
        
            agent: agent,
        
          });
        
          console.log(await response.text());
        
          import fetch from 'node-fetch';
        
          import createHttpsProxyAgent from 'https-proxy-agent';
        
          const username = 'td-customer-USERNAME';
        
          const password = 'PASS';
        
          const proxy = 'IP:PORT';
        
          const agent = createHttpsProxyAgent(
        
            `http://${username}:${password}@${proxy}`
        
          );
        
          const response = await fetch('https://ipinfo.zytedata.com', {
        
            method: 'get',
        
            agent: agent,
        
          });
        
          console.log(await response.text());
        
          import fetch from 'node-fetch';
        
          import createHttpsProxyAgent from 'https-proxy-agent';
        
          const username = 'td-customer-USERNAME';
        
          const password = 'PASS';
        
          const proxy = 'unlimited.zytedata.com:9999';
        
          const agent = createHttpsProxyAgent(
        
            `http://${username}:${password}@${proxy}`
        
          );
        
          const response = await fetch('https://ipinfo.zytedata.com', {
        
            method: 'get',
        
            agent: agent,
        
          });
        
          console.log(await response.text());
        
          import fetch from 'node-fetch';
        
          import createHttpsProxyAgent from 'https-proxy-agent';
        
          const username = 'td-customer-USERNAME';
        
          const password = 'PASS';
        
          const proxy = 'user.pr.zytedata.com:5555';
        
          const agent = createHttpsProxyAgent(
        
            `http://${username}:${password}@${proxy}`
        
          );
        
          const response = await fetch('https://ipinfo.zytedata.com', {
        
            method: 'get',
        
            agent: agent,
        
          });
        
          console.log(await response.text());
        
          const axios = require('axios');
        
          const qs = require('querystring');
        
          async function main() {
        
            const targetURL = "https://scraperapi.zytedata.com/builder";
        
            const spiderInfo = [
        
              {
        
                "url": "https://www.youtube.com/@stephcurry/videos",
        
                "order_by": "",
        
                "num_of_posts": ""
        
              }
        
            ];
        
            try {
        
              const spiderInfoJSON = JSON.stringify(spiderInfo);
        
              const formData = qs.stringify({
        
                spider_name: "youtube.com",
        
                spider_id: "youtube_video-post_by-url",
        
                spider_parameters: spiderInfoJSON,
        
                spider_errors: true,
        
                file_name: "{{VideoID}}"
        
              });
        
              const response = await axios.post(targetURL, formData, {
        
                headers: {
        
                  'Authorization': 'Bearer Token',
        
                  'Content-Type': 'application/x-www-form-urlencoded'
        
                }
        
              });
        
              console.log(`Status Code: ${response.status}`);
        
              console.log(`Response Body: ${JSON.stringify(response.data)}`);
        
            } catch (error) {
        
              if (error.response) {
        
                console.error(`Error response: ${error.response.status} - ${error.response.data}`);
        
              } else if (error.request) {
        
                console.error('No response received:', error.request);
        
              } else {
        
                console.error('Error:', error.message);
        
              }
        
            }
        
          }
        
          main();
        
          const https = require("https");
        
          const querystring = require("querystring"); 
        
          const options = {
        
              method: "POST",
        
              hostname: "webunlocker.zytedata.com",
        
              path: "/request",
        
              headers: {
        
                  "Authorization": "Bearer Token",
        
                  "content-type": "application/x-www-form-urlencoded" 
        
              }
        
          };
        
          const formData = {
        
              url: "https://www.google.com",
        
              type: "html",
        
              js_render: "True"
        
          };
        
          const formDataString = querystring.stringify(formData);
        
          options.headers["Content-Length"] = formDataString.length;
        
          const req = https.request(options, (res) => {
        
              const chunks = [];
        
              res.on("data", (chunk) => chunks.push(chunk));
        
              res.on("end", () => {
        
                  const body = Buffer.concat(chunks);
        
                  console.log(body.toString());
        
              });
        
          });
        
          req.write(formDataString);
        
          req.end();
        
          const axios = require('axios');
        
          const params = new URLSearchParams({
        
                  engine: 'google',
        
                  q: 'pizza',
        
                  json: '1'
        
          });
        
          const config = {
        
              method: 'post',
        
              url: 'https://scraperapi.zytedata.com/request',
        
              headers: { 
        
                  Authorization: 'Bearer Token',
        
                  'Content-Type': 'application/x-www-form-urlencoded'
        
              },
        
              data: params
        
          };
        
          axios.request(config)
        
              .then((response) => {
        
                  console.log(JSON.stringify(response.data));
        
              })
        
              .catch((error) => {
        
                  console.log(error);
        
          });
        
          <?php
        
          $username = 'td-customer-USERNAME';
        
          $password = 'PASS';
        
          $proxy = 'user.pr.zytedata.com:9999';
        
          $query = curl_init('https://ipinfo.zytedata.com');
        
          curl_setopt($query, CURLOPT_RETURNTRANSFER, 1);
        
          curl_setopt($query, CURLOPT_PROXY, "http://$proxy");
        
          curl_setopt($query, CURLOPT_PROXYUSERPWD, "$username:$password");
        
          $output = curl_exec($query);
        
          curl_close($query);
        
          if ($output)
        
              echo $output;
        
          ?>
        
          <?php
        
          $username = 'td-customer-USERNAME';
        
          $password = 'PASS';
        
          $proxy = 'IP:PORT';
        
          $query = curl_init('https://ipinfo.zytedata.com');
        
          curl_setopt($query, CURLOPT_RETURNTRANSFER, 1);
        
          curl_setopt($query, CURLOPT_PROXY, "http://$proxy");
        
          curl_setopt($query, CURLOPT_PROXYUSERPWD, "$username:$password");
        
          $output = curl_exec($query);
        
          curl_close($query);
        
          if ($output)
        
              echo $output;
        
          ?>
        
          <?php
        
          $username = 'td-customer-USERNAME';
        
          $password = 'PASS';
        
          $proxy = 'IP:PORT';
        
          $query = curl_init('https://ipinfo.zytedata.com');
        
          curl_setopt($query, CURLOPT_RETURNTRANSFER, 1);
        
          curl_setopt($query, CURLOPT_PROXY, "http://$proxy");
        
          curl_setopt($query, CURLOPT_PROXYUSERPWD, "$username:$password");
        
          $output = curl_exec($query);
        
          curl_close($query);
        
          if ($output)
        
              echo $output;
        
          ?>
        
          <?php
        
          $username = 'td-customer-USERNAME';
        
          $password = 'PASS';
        
          $proxy = 'unlimited.zytedata.com:9999';
        
          $query = curl_init('https://ipinfo.zytedata.com');
        
          curl_setopt($query, CURLOPT_RETURNTRANSFER, 1);
        
          curl_setopt($query, CURLOPT_PROXY, "http://$proxy");
        
          curl_setopt($query, CURLOPT_PROXYUSERPWD, "$username:$password");
        
          $output = curl_exec($query);
        
          curl_close($query);
        
          if ($output)
        
              echo $output;
        
          ?>
        
          <?php
        
          $username = 'td-customer-USERNAME';
        
          $password = 'PASS';
        
          $proxy = 'user.pr.zytedata.com:5555';
        
          $query = curl_init('https://ipinfo.zytedata.com');
        
          curl_setopt($query, CURLOPT_RETURNTRANSFER, 1);
        
          curl_setopt($query, CURLOPT_PROXY, "http://$proxy");
        
          curl_setopt($query, CURLOPT_PROXYUSERPWD, "$username:$password");
        
          $output = curl_exec($query);
        
          curl_close($query);
        
          if ($output)
        
              echo $output;
        
          ?>
        
          <?php
        
          $targetURL = "https://scraperapi.zytedata.com/builder";
        
          $spiderInfo = [
        
            [
        
              "url" => "https://www.youtube.com/@stephcurry/videos",
        
              "order_by" => "",
        
              "num_of_posts" => ""
        
            ]
        
          ];
        
          $spiderInfoJSON = json_encode($spiderInfo);
        
          if ($spiderInfoJSON === false) {
        
            die("Error marshaling JSON: " . json_last_error_msg());
        
          }
        
          $formData = [
        
            "spider_name" => "youtube.com",
        
            "spider_id" => "youtube_video-post_by-url",
        
            "spider_parameters" => $spiderInfoJSON,
        
            "spider_errors" => true,
        
            "file_name" => "{{VideoID}}"
        
          ];
        
          $options = [
        
            "http" => [
        
              "method" => "POST",
        
              "header" => implode("\r\n", [
        
                "Authorization: Bearer Token",
        
                "Content-Type: application/x-www-form-urlencoded",
        
                "Accept: application/json"
        
              ]),
        
              "content" => http_build_query($formData)
        
            ]
        
          ];
        
          $context = stream_context_create($options);
        
          $response = file_get_contents($targetURL, false, $context);
        
          if ($response === false) {
        
            $error = error_get_last();
        
            die("Error sending request: " . $error["message"]);
        
          }
        
          // Get HTTP status code
        
          $statusCode = null;
        
          if (isset($http_response_header[0])) {
        
            preg_match('/HTTP\/\d\.\d (\d{3})/', $http_response_header[0], $matches);
        
            $statusCode = $matches[1] ?? null;
        
          }
        
          echo "Status Code: " . $statusCode . "\n";
        
          echo "Response Body: " . $response . "\n";
        
          ?>
        
          <?php
        
          $data = [
        
              'url'=> 'https://www.google.com',
        
              'type'=> 'html',
        
              'js_render'=> 'True'
        
          ];
        
          $queryString = http_build_query($data);
        
          $curl = curl_init();
        
          curl_setopt_array($curl, [
        
              CURLOPT_URL => "https://webunlocker.zytedata.com/request",
        
              CURLOPT_RETURNTRANSFER => true,
        
              CURLOPT_ENCODING => "",
        
              CURLOPT_MAXREDIRS => 10,
        
              CURLOPT_TIMEOUT => 30,
        
              CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
        
              CURLOPT_CUSTOMREQUEST => "POST",
        
          CURLOPT_POSTFIELDS => $queryString, 
        
          CURLOPT_HTTPHEADER => [
        
                  "Authorization: Bearer Token",
        
                  "content-type: application/x-www-form-urlencoded" 
        
              ],
        
          ]);
        
          $response = curl_exec($curl);
        
          $err = curl_error($curl);
        
          curl_close($curl);
        
          if ($err) {
        
              echo "cURL Error #:" . $err;
        
          } else {
        
              echo $response;
        
          }
        
          ?>
        
          <?php
        
          $curl = curl_init();
        
          $data = [
        
                  "engine" => "google",
        
                  "q" => "pizza",
        
                  "json" => "1"
        
          ];
        
          curl_setopt_array($curl, array(
        
              CURLOPT_URL => 'https://scraperapi.zytedata.com/request',
        
              CURLOPT_RETURNTRANSFER => true,
        
              CURLOPT_ENCODING => '',
        
              CURLOPT_MAXREDIRS => 10,
        
              CURLOPT_TIMEOUT => 0,
        
              CURLOPT_FOLLOWLOCATION => true,
        
              CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
        
              CURLOPT_CUSTOMREQUEST => 'POST',
        
              CURLOPT_POSTFIELDS => http_build_query($data),
        
              CURLOPT_HTTPHEADER => array(
        
                  'Authorization: Bearer Token',
        
                  'Content-Type: application/x-www-form-urlencoded'
        
              ),
        
          ));
        
          $response = curl_exec($curl);
        
          curl_close($curl);
        
          echo $response;
        
          ?>
        
          package main
        
          import (
        
            "fmt"
        
            "io/ioutil"
        
            "net/http"
        
            "net/url"
        
          )
        
          func main() {
        
            const username = "td-customer-USERNAME"
        
            const password = "PASS"
        
            const proxy = "user.pr.zytedata.com:9999"
        
            proxyUrl, _ := url.Parse(
        
              fmt.Sprintf(
        
                "http://%s:%s@%s",
        
                username,
        
                password,
        
                proxy,
        
              ),
        
            )
        
            client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}
        
            request, _ := http.NewRequest("GET",
        
              "https://ipinfo.zytedata.com",
        
              nil,
        
            )
        
            request.SetBasicAuth(username, password)
        
            response, err := client.Do(request)
        
            if err != nil {
        
              fmt.Println(err)
        
              return
        
            }
        
            responseText, _ := ioutil.ReadAll(response.Body)
        
            fmt.Println(string(responseText))
        
          }
        
          package main
        
          import (
        
            "fmt"
        
            "io/ioutil"
        
            "net/http"
        
            "net/url"
        
          )
        
          func main() {
        
            const username = "td-customer-USERNAME"
        
            const password = "PASS"
        
            const proxy = "IP:PORT"
        
            proxyUrl, _ := url.Parse(
        
              fmt.Sprintf(
        
                "http://%s:%s@%s",
        
                username,
        
                password,
        
                proxy,
        
              ),
        
            )
        
            client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}
        
            request, _ := http.NewRequest("GET",
        
              "https://ipinfo.zytedata.com",
        
              nil,
        
            )
        
            request.SetBasicAuth(username, password)
        
            response, err := client.Do(request)
        
            if err != nil {
        
              fmt.Println(err)
        
              return
        
            }
        
            responseText, _ := ioutil.ReadAll(response.Body)
        
            fmt.Println(string(responseText))
        
          }
        
          package main
        
          import (
        
            "fmt"
        
            "io/ioutil"
        
            "net/http"
        
            "net/url"
        
          )
        
          func main() {
        
            const username = "td-customer-USERNAME"
        
            const password = "PASS"
        
            const proxy = "IP:PORT"
        
            proxyUrl, _ := url.Parse(
        
              fmt.Sprintf(
        
                "http://%s:%s@%s",
        
                username,
        
                password,
        
                proxy,
        
              ),
        
            )
        
            client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}
        
            request, _ := http.NewRequest("GET",
        
              "https://ipinfo.zytedata.com",
        
              nil,
        
            )
        
            request.SetBasicAuth(username, password)
        
            response, err := client.Do(request)
        
            if err != nil {
        
              fmt.Println(err)
        
              return
        
            }
        
            responseText, _ := ioutil.ReadAll(response.Body)
        
            fmt.Println(string(responseText))
        
          }
        
          package main
        
          import (
        
            "fmt"
        
            "io/ioutil"
        
            "net/http"
        
            "net/url"
        
          )
        
          func main() {
        
            const username = "td-customer-USERNAME"
        
            const password = "PASS"
        
            const proxy = "unlimited.zytedata.com:9999"
        
            proxyUrl, _ := url.Parse(
        
              fmt.Sprintf(
        
                "http://%s:%s@%s",
        
                username,
        
                password,
        
                proxy,
        
              ),
        
            )
        
            client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}
        
            request, _ := http.NewRequest("GET",
        
              "https://ipinfo.zytedata.com",
        
              nil,
        
            )
        
            request.SetBasicAuth(username, password)
        
            response, err := client.Do(request)
        
            if err != nil {
        
              fmt.Println(err)
        
              return
        
            }
        
            responseText, _ := ioutil.ReadAll(response.Body)
        
            fmt.Println(string(responseText))
        
          }
        
          package main
        
          import (
        
            "fmt"
        
            "io/ioutil"
        
            "net/http"
        
            "net/url"
        
          )
        
          func main() {
        
            const username = "td-customer-USERNAME"
        
            const password = "PASS"
        
            const proxy = "user.pr.zytedata.com:5555"
        
            proxyUrl, _ := url.Parse(
        
              fmt.Sprintf(
        
                "http://%s:%s@%s",
        
                username,
        
                password,
        
                proxy,
        
              ),
        
            )
        
            client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}
        
            request, _ := http.NewRequest("GET",
        
              "https://ipinfo.zytedata.com",
        
              nil,
        
            )
        
            request.SetBasicAuth(username, password)
        
            response, err := client.Do(request)
        
            if err != nil {
        
              fmt.Println(err)
        
              return
        
            }
        
            responseText, _ := ioutil.ReadAll(response.Body)
        
            fmt.Println(string(responseText))
        
          }
        
          package main
        
          import (
        
            "encoding/json"
        
            "fmt"
        
            "io"
        
            "net/http"
        
            "net/url"
        
            "strings"
        
          )
        
          func main() {
        
            client := &http.Client{}
        
            targetURL := "https://scraperapi.zytedata.com/builder"
        
            spiderInfo := []map[string]string{ 
        
              {
        
                "url": "https://www.youtube.com/@stephcurry/videos",
        
                "order_by": "",
        
                "num_of_posts": "",
        
              },
        
            }
        
            spiderInfoJSON, err := json.Marshal(spiderInfo)
        
            if err != nil {
        
              fmt.Println("Error marshaling JSON:", err)
        
              return
        
            }
        
            formData := url.Values{}
        
            formData.Add("spider_name", "youtube.com")
        
            formData.Add("spider_id", "youtube_video-post_by-url")
        
            formData.Add("spider_parameters", string(spiderInfoJSON))
        
            formData.Add("spider_errors", "true")
        
            formData.Add("file_name", "{{VideoID}}")
        
            req, err := http.NewRequest("POST", targetURL, strings.NewReader(formData.Encode()))
        
            if err != nil {
        
              fmt.Println("Error creating request:", err)
        
              return
        
            }
        
            req.Header.Set("Authorization", "Bearer Token")
        
            req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
        
            resp, err := client.Do(req)
        
            if err != nil {
        
              fmt.Println("Error sending request:", err)
        
              return
        
            }
        
            defer resp.Body.Close()
        
            body, err := io.ReadAll(resp.Body)
        
            if err != nil {
        
              fmt.Println("Error reading response:", err)
        
              return
        
            }
        
            fmt.Printf("Status Code: %d\n", resp.StatusCode)
        
            fmt.Printf("Response Body: %s\n", body)
        
          }
        
          package main
        
          import (
        
          	"fmt"
        
          	"io/ioutil"
        
          	"log"
        
          	"net/http"
        
          	"net/url"
        
          	"strings"
        
          	"time"
        
          )
        
          func main() {
        
          	var apiKey = "Token"
        
          	var targetURL = "https://webunlocker.zytedata.com/request"
        
          	formData := url.Values{
        
              "url": {"https://www.google.com"},
        
              "type": {"html"},
        
              "js_render": {"True"},
        
              }
        
          	client := &http.Client{Timeout: 30 * time.Second}
        
          	req, err := http.NewRequest("POST", targetURL, strings.NewReader(formData.Encode()))
        
          	if err != nil {
        
          		log.Fatal("Create request failed:", err)
        
          	}
        
          	req.Header = http.Header{
        
          		"Authorization": {"Bearer " + apiKey},
        
          		"Content-Type":  {"application/x-www-form-urlencoded"},
        
          	}
        
          	res, err := client.Do(req)
        
          	if err != nil {
        
          		log.Fatal("Failed to send request:", err)
        
          	}
        
          	defer res.Body.Close()
        
          	body, err := ioutil.ReadAll(res.Body)
        
          	if err != nil {
        
          		log.Fatal("Failed to read response:", err)
        
          	}
        
          	fmt.Printf("Status: %d Content:%s", res.StatusCode, body)
        
          }
        
          package main
        
          import (
        
                  "fmt"
        
                  "net/http"
        
                  "net/url"  
        
                  "strings"
        
                  "io"
        
          )
        
          func main(){
        
                  urlStr := "https://scraperapi.zytedata.com/request"
        
                  method := "POST"
        
                  formData := url.Values{
        
                           "engine": {"google"},
        
                           "q": {"pizza"},
        
                          "json": {"1"},
        
                  }
        
                  payload := strings.NewReader(formData.Encode())
        
                  client := &http.Client{}
        
                  req, err := http.NewRequest(method, urlStr, payload)
        
                  if err != nil {
        
                          fmt.Println(err)
        
                                  return
        
                  }
        
                  req.Header.Add("Authorization", "Bearer Token")
        
          	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
        
                  res, err := client.Do(req)
        
                  if err != nil {
        
                          fmt.Println(err)
        
                                  return
        
                  }
        
                  defer res.Body.Close()
        
                  body, err := io.ReadAll(res.Body)
        
                  if err != nil {
        
                          fmt.Println(err)
        
                                  return
        
                  }
        
                  fmt.Println(string(body))
        
          }
        
          package example;
        
          import org.apache.http.HttpHost;
        
          import org.apache.http.client.fluent.*;
        
          public class Main {
        
            public static void main(String[] args) throws Exception {
        
              String username = "td-customer-USERNAME";
        
              String password = "PASS";
        
              String proxyHost = "user.pr.zytedata.com";
        
              int proxyPort = 9999;
        
              HttpHost entry = new HttpHost(proxyHost, proxyPort);
        
              String query = Executor.newInstance()
        
                  .auth(entry, username, password)
        
                  .execute(Request.Get("https://ipinfo.zytedata.com")
        
                  .viaProxy(entry))
        
                  .returnContent()
        
                  .asString();
        
              System.out.println(query);
        
            }
        
          }
        
          package example;
        
          import org.apache.http.HttpHost;
        
          import org.apache.http.client.fluent.*;
        
          public class Main {
        
            public static void main(String[] args) throws Exception {
        
              String username = "td-customer-USERNAME";
        
              String password = "PASS";
        
              String proxyHost = "IP";
        
              int proxyPort = PORT;
        
              HttpHost entry = new HttpHost(proxyHost, proxyPort);
        
              String query = Executor.newInstance()
        
                  .auth(entry, username, password)
        
                  .execute(Request.Get("https://ipinfo.zytedata.com")
        
                  .viaProxy(entry))
        
                  .returnContent()
        
                  .asString();
        
              System.out.println(query);
        
            }
        
          }
        
          package example;
        
          import org.apache.http.HttpHost;
        
          import org.apache.http.client.fluent.*;
        
          public class Main {
        
            public static void main(String[] args) throws Exception {
        
              String username = "td-customer-USERNAME";
        
              String password = "PASS";
        
              String proxyHost = "IP";
        
              int proxyPort = PORT;
        
              HttpHost entry = new HttpHost(proxyHost, proxyPort);
        
              String query = Executor.newInstance()
        
                  .auth(entry, username, password)
        
                  .execute(Request.Get("https://ipinfo.zytedata.com")
        
                  .viaProxy(entry))
        
                  .returnContent()
        
                  .asString();
        
              System.out.println(query);
        
            }
        
          }
        
          package example;
        
          import org.apache.http.HttpHost;
        
          import org.apache.http.client.fluent.*;
        
          public class Main {
        
            public static void main(String[] args) throws Exception {
        
              String username = "td-customer-USERNAME";
        
              String password = "PASS";
        
              String proxyHost = "unlimited.zytedata.com";
        
              int proxyPort = 9999;
        
              HttpHost entry = new HttpHost(proxyHost, proxyPort);
        
              String query = Executor.newInstance()
        
                  .auth(entry, username, password)
        
                  .execute(Request.Get("https://ipinfo.zytedata.com")
        
                  .viaProxy(entry))
        
                  .returnContent()
        
                  .asString();
        
              System.out.println(query);
        
            }
        
          }
        
          package example;
        
          import org.apache.http.HttpHost;
        
          import org.apache.http.client.fluent.*;
        
          public class Main {
        
            public static void main(String[] args) throws Exception {
        
              String username = "td-customer-USERNAME";
        
              String password = "PASS";
        
              String proxyHost = "user.pr.zytedata.com";
        
              int proxyPort = 5555;
        
              HttpHost entry = new HttpHost(proxyHost, proxyPort);
        
              String query = Executor.newInstance()
        
                  .auth(entry, username, password)
        
                  .execute(Request.Get("https://ipinfo.zytedata.com")
        
                  .viaProxy(entry))
        
                  .returnContent()
        
                  .asString();
        
              System.out.println(query);
        
            }
        
          }
        
          import java.io.*;
        
          import java.net.HttpURLConnection;
        
          import java.net.URL;
        
          import java.net.URLEncoder;
        
          import java.nio.charset.StandardCharsets;
        
          import java.util.ArrayList;
        
          import java.util.HashMap;
        
          import java.util.List;
        
          import java.util.Map;
        
          public class Main {
        
            public static void main(String[] args) {
        
              String targetURL = "https://scraperapi.zytedata.com/builder";
        
              // Create the spider info data structure
        
              List<Map<String, String>> spiderInfo = new ArrayList<>();
        
              Map<String, String> param1 = new HashMap<>();
        
                param1.put("url", "https://www.youtube.com/@stephcurry/videos");
        
                param1.put("order_by", "");
        
                param1.put("num_of_posts", "");
        
                spiderInfo.add(param1);
        
              try {
        
                // Convert spiderInfo to JSON
        
                String spiderInfoJSON = new com.google.gson.Gson().toJson(spiderInfo);
        
                // Prepare form data
        
                String formData = "spider_name=" + URLEncoder.encode("youtube.com", StandardCharsets.UTF_8) + 
        
                "&spider_id=" + URLEncoder.encode("youtube_video-post_by-url", StandardCharsets.UTF_8) + 
        
                "&spider_parameters=" + URLEncoder.encode(spiderInfoJSON, StandardCharsets.UTF_8) + 
        
                "&spider_errors=" + URLEncoder.encode("true", StandardCharsets.UTF_8) + 
        
                "&file_name=" + URLEncoder.encode("{{VideoID}}", StandardCharsets.UTF_8);
        
                // Create and configure the connection
        
                HttpURLConnection connection = (HttpURLConnection) new URL(targetURL).openConnection();
        
                connection.setRequestMethod("POST");
        
                connection.setRequestProperty("Authorization", "Bearer Token");
        
                connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
        
                connection.setDoOutput(true);
        
                // Send the request
        
                try (OutputStream os = connection.getOutputStream()) {
        
                  byte[] input = formData.getBytes(StandardCharsets.UTF_8);
        
                  os.write(input, 0, input.length);
        
                }
        
                // Get the response
        
                int statusCode = connection.getResponseCode();
        
                String responseBody;
        
                try (InputStream is = connection.getInputStream();
        
                  BufferedReader br = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8))) {
        
                  StringBuilder response = new StringBuilder();
        
                  String responseLine;
        
                  while ((responseLine = br.readLine()) != null) {
        
                    response.append(responseLine.trim());
        
                  }
        
                  responseBody = response.toString();
        
                }
        
                System.out.println("Status Code: " + statusCode);
        
                System.out.println("Response Body: " + responseBody);
        
              } catch (Exception e) {
        
                System.err.println("Error: " + e.getMessage());
        
                e.printStackTrace();
        
              }
        
            }
        
          }
        
          import java.net.URI;
        
          import java.net.http.HttpClient;
        
          import java.net.http.HttpRequest;
        
          import java.net.http.HttpResponse;
        
          import java.net.URLEncoder;
        
          import java.nio.charset.StandardCharsets;
        
          import java.util.Map;
        
          import java.util.stream.Collectors;
        
          public class Main {
        
              public static void main(String[] args) throws Exception {
        
                  String formData = buildFormData(
        
                      "url", "https://www.google.com",
        
                      "type", "html",
        
                      "js_render", "True"
        
              );
        
                  HttpRequest request = HttpRequest.newBuilder()
        
                          .uri(URI.create("https://webunlocker.zytedata.com/request"))
        
                          .header("Authorization", "Bearer Token")
        
                          .header("content-type", "application/x-www-form-urlencoded")
        
                          .POST(HttpRequest.BodyPublishers.ofString(formData))
        
                          .build();
        
                  HttpResponse<String> response = HttpClient.newHttpClient()
        
                          .send(request, HttpResponse.BodyHandlers.ofString());
        
                  System.out.println(response.body());
        
              }
        
              private static String buildFormData(String... keyValuePairs) {
        
                  if (keyValuePairs.length % 2 != 0) {
        
                      throw new IllegalArgumentException("Parameters must be key-value pairs.");
        
                  }
        
                  StringBuilder sb = new StringBuilder();
        
                  for (int i = 0; i < keyValuePairs.length; i += 2) {
        
                      if (i > 0) sb.append("&");
        
                      sb.append(keyValuePairs[i])
        
                        .append("=")
        
                        .append(URLEncoder.encode(keyValuePairs[i+1], StandardCharsets.UTF_8));
        
                  }
        
                  return sb.toString();
        
              }
        
          }
        
          import java.io.*;
        
          import java.net.HttpURLConnection;
        
          import java.net.URL;
        
          import java.net.URLEncoder;
        
          public class ScraperApiExample {
        
              public static void main(String[] args) {
        
                  try {
        
                      String formData = String.format("engine=%s&q=%s&json=%s",
        
                              URLEncoder.encode("google", "UTF-8"),
        
                              URLEncoder.encode("pizza", "UTF-8"),
        
                              URLEncoder.encode("1", "UTF-8"));
        
                      URL url = new URL("https://scraperapi.zytedata.com/request");
        
                      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        
                      conn.setRequestMethod("POST");
        
                      conn.setDoOutput(true);
        
                      conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
        
                      conn.setRequestProperty("Authorization", "Bearer Token");
        
                      try (DataOutputStream dos = new DataOutputStream(conn.getOutputStream())) {
        
                          dos.writeBytes(formData);
        
                          dos.flush();
        
                      }
        
                      int responseCode = conn.getResponseCode();
        
                      StringBuilder response = new StringBuilder();
        
                      try (BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()))) {
        
                          String inputLine;
        
                          while ((inputLine = in.readLine()) != null) {
        
                              response.append(inputLine);
        
                          }
        
                      }
        
                      System.out.println("Status: " + responseCode);
        
                      System.out.println("Body: " + response.toString());
        
                      conn.disconnect();
        
                  } catch (Exception e) {
        
                      e.printStackTrace();
        
                  }
        
              }
        
          }
        
          using System;
        
          using System.Net;
        
          class Example
        
          {
        
            static void Main()
        
            {  
        
              var username = "td-customer-USERNAME";
        
              var password = "PASS";
        
              var proxy = "user.pr.zytedata.com:9999";
        
              var client = new WebClient();
        
              client.Proxy = new WebProxy(proxy);
        
              client.Proxy.Credentials = new NetworkCredential(username, password);
        
              Console.WriteLine(client.DownloadString("https://ipinfo.zytedata.com"));
        
            }
        
          }
        
          using System;
        
          using System.Net;
        
          class Example
        
          {
        
            static void Main()
        
            {  
        
              var username = "td-customer-USERNAME";
        
              var password = "PASS";
        
              var proxy = "IP:PORT";
        
              var client = new WebClient();
        
              client.Proxy = new WebProxy(proxy);
        
              client.Proxy.Credentials = new NetworkCredential(username, password);
        
              Console.WriteLine(client.DownloadString("https://ipinfo.zytedata.com"));
        
            }
        
          }
        
          using System;
        
          using System.Net;
        
          class Example
        
          {
        
            static void Main()
        
            {  
        
              var username = "td-customer-USERNAME";
        
              var password = "PASS";
        
              var proxy = "IP:PORT";
        
              var client = new WebClient();
        
              client.Proxy = new WebProxy(proxy);
        
              client.Proxy.Credentials = new NetworkCredential(username, password);
        
              Console.WriteLine(client.DownloadString("https://ipinfo.zytedata.com"));
        
            }
        
          }
        
          using System;
        
          using System.Net;
        
          class Example
        
          {
        
            static void Main()
        
            {  
        
              var username = "td-customer-USERNAME";
        
              var password = "PASS";
        
              var proxy = "unlimited.zytedata.com:9999";
        
              var client = new WebClient();
        
              client.Proxy = new WebProxy(proxy);
        
              client.Proxy.Credentials = new NetworkCredential(username, password);
        
              Console.WriteLine(client.DownloadString("https://ipinfo.zytedata.com"));
        
            }
        
          }
        
          using System;
        
          using System.Net;
        
          class Example
        
          {
        
            static void Main()
        
            {  
        
              var username = "td-customer-USERNAME";
        
              var password = "PASS";
        
              var proxy = "user.pr.zytedata.com:5555";
        
              var client = new WebClient();
        
              client.Proxy = new WebProxy(proxy);
        
              client.Proxy.Credentials = new NetworkCredential(username, password);
        
              Console.WriteLine(client.DownloadString("https://ipinfo.zytedata.com"));
        
            }
        
          }
        
          using System;
        
          using System.Collections.Generic;
        
          using System.Net.Http;
        
          using System.Text;
        
          using System.Threading.Tasks;
        
          using System.Web.Http;
        
          class Program
        
          {
        
            static async Task Main(string[] args)
        
            {
        
              var client = new HttpClient();
        
              var targetUrl = "https://scraperapi.zytedata.com/builder";
        
              var spiderInfo = new List<Dictionary<string, string>>
        
              {
        
                new Dictionary<string, string>
        
                {
        
                  {"url", "https://www.youtube.com/@stephcurry/videos"},
        
                  {"order_by", ""},
        
                  {"num_of_posts", ""}
        
                }
        
              };
        
              var spiderInfoJson = Newtonsoft.Json.JsonConvert.SerializeObject(spiderInfo);
        
              var formData = new Dictionary<string, string>
        
              {
        
                { "spider_name", "youtube.com" },
        
                { "spider_id", "youtube_video-post_by-url" },
        
                { "spider_parameters", spiderInfoJson },
        
                { "spider_errors", "true" },
        
                { "file_name", "{{VideoID}}"}
        
              };
        
              var request = new HttpRequestMessage(HttpMethod.Post, targetUrl)
        
              {
        
                Content = new FormUrlEncodedContent(formData)
        
              };
        
              request.Headers.Add("Authorization", "Bearer Token");
        
              try
        
              {
        
                var response = await client.SendAsync(request);
        
                var responseBody = await response.Content.ReadAsStringAsync();
        
                Console.WriteLine($"Status Code: {(int)response.StatusCode}");
        
                Console.WriteLine($"Response Body: {responseBody}");
        
              }
        
              catch (HttpRequestException e)
        
              {
        
                Console.WriteLine($"Error sending request: {e.Message}");
        
              }
        
            }
        
          }
        
          using System; 
        
          using System.Net.Http; 
        
          using System.Net.Http.Headers; 
        
          using System.Collections.Generic; 
        
          using System.Threading.Tasks; 
        
          using System.Web; 
        
          class Program 
        
          { 
        
              static async Task Main(string[] args) 
        
              {  
        
                  var client = new HttpClient(); 
        
                  var request = new HttpRequestMessage 
        
                  { 
        
                      Method = HttpMethod.Post, 
        
                      RequestUri = new Uri(" https://webunlocker.zytedata.com/request"), 
        
                      Headers = 
        
                      { 
        
                          { "Authorization", "Bearer Token" },
        
                      }, 
        
                      Content = new FormUrlEncodedContent(new Dictionary<string, string> 
        
                      {
        
                      {"url", "https://www.google.com"},
        
                      {"type", "html"},
        
                      {"js_render", "True"}
        
                      })
        
                  }; 
        
                  request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded"); 
        
                  using (var response = await client.SendAsync(request)) 
        
                  { 
        
                      response.EnsureSuccessStatusCode(); 
        
                      var body = await response.Content.ReadAsStringAsync(); 
        
                      Console.WriteLine(body); 
        
                  } 
        
              } 
        
          }
        
          using System;
        
          using System.Collections.Generic;
        
          using System.Net.Http;
        
          using System.Threading.Tasks;
        
          class Program
        
          {
        
              static async Task Main(string[] args)
        
              {
        
                  var client = new HttpClient();
        
                  var request = new HttpRequestMessage(
        
                      HttpMethod.Post, 
        
                      "https://scraperapi.zytedata.com/request"
        
                  );
        
                  request.Headers.Add("Authorization", "Bearer Token");
        
                  var formData = new Dictionary<string, string>
        
                  {
        
                  {"engine", "google"},
        
                  {"q", "pizza"},
        
                  {"json", "1"}
        
          };
        
                  var content = new FormUrlEncodedContent(formData);
        
                  request.Content = content;
        
                  var response = await client.SendAsync(request);
        
                  response.EnsureSuccessStatusCode();
        
                  Console.WriteLine(await response.Content.ReadAsStringAsync());
        
              }
        
          }
        
Python
cURL
Node.js
PHP
GO
Java
C#

Tích hợp dễ dàng, tài liệu chi tiết

Quản lý hiệu quả proxy ẩn danh của bạn bằng API và các tính năng tích hợp của chúng tôi. Tìm các ví dụ mã và hướng dẫn để đảm bảo kết nối mượt mà với công cụ của bạn.

Tài liệu tích hợp thân thiện với người mới bắt đầu

Tạo và quản lý tài khoản phụ

Hỗ trợ tích hợp phần mềm bên thứ ba

Nhiều tùy chọn ngôn ngữ lập trình

Xem tài liệu Bắt đầu sử dụng

Lợi ích của Elite Proxy Thordata

Dù bạn cần thu thập dữ liệu quy mô lớn hay bảo vệ danh tính trực tuyến, Thordata có thể cung cấp cho bạn các địa chỉ IP phù hợp.

Proxy tuân thủ 100%

Chúng tôi hợp tác với các nguồn đáng tin cậy để cung cấp dữ liệu IP tuân thủ 100%, đảm bảo an toàn và đáng tin cậy.

Chất lượng dữ liệu vượt trội

Mỗi proxy trong hệ thống đều được chọn lọc trước và kiểm tra tải để đáp ứng ngay cả những nhu cầu kinh doanh khắt khe nhất.

Hỗ trợ 24/7

Đội ngũ hỗ trợ chuyên nghiệp luôn sẵn sàng giúp đỡ và giải quyết mọi vấn đề kỹ thuật, giúp công việc của bạn luôn hiệu quả.

Giải pháp tùy chỉnh

Chúng tôi cung cấp các giải pháp dữ liệu doanh nghiệp linh hoạt, có thể mở rộng và tùy chỉnh để đáp ứng nhu cầu kinh doanh độc đáo và thúc đẩy tăng trưởng.

Doanh nghiệp sử dụng dịch vụ Elite Proxy của chúng tôi như thế nào?

Sử dụng proxy elite được thiết kế riêng cho doanh nghiệp của bạn để thực hiện các tác vụ mà không bị hạn chế.

Giám sát SERP

Thương mại điện tử

Bảo vệ email

Xác minh quảng cáo

Giám sát giá cả

Bảo vệ thương hiệu

Giám sát đánh giá

Nghiên cứu thị trường

Tạo dữ liệu AI

An ninh mạng

Vấn đề phổ biến

Elite Proxies là gì?

Elite proxies, còn được gọi là proxy ẩn danh cao cấp hoặc proxy Cấp 1, cung cấp mức độ bảo mật và quyền riêng tư cao hơn so với proxy thông thường. Chúng không tiết lộ bất kỳ thông tin nào về người dùng, phù hợp cho các tình huống yêu cầu tính ẩn danh cao, vượt qua hạn chế địa lý và tránh bị chặn.

Sự khác biệt giữa Elite Proxies và Anonymous Proxies là gì?

Sự khác biệt chính nằm ở mức độ ẩn danh và bảo vệ quyền riêng tư. Proxy ẩn danh chỉ che giấu địa chỉ IP thực của người dùng nhưng có thể tiết lộ với trang web mục tiêu rằng một proxy đang được sử dụng. Trong khi đó, elite proxies cung cấp mức độ bảo vệ cao hơn, không chỉ ẩn địa chỉ IP thực mà còn đảm bảo trang web không thể phát hiện người dùng đang sử dụng proxy.

Làm thế nào để có được Elite Proxies?

Trước tiên, bạn cần chọn một nhà cung cấp elite proxy đáng tin cậy. Các bước mua proxy từ Thordata:

Tạo tài khoản.

Truy cập bảng điều khiển và chọn loại proxy phù hợp với nhu cầu của bạn (Residential, ISP hoặc Datacenter Proxies).

Sau khi thanh toán, bạn sẽ nhận được thông tin proxy trên bảng điều khiển.

Cấu hình proxy và áp dụng nó vào các ứng dụng, trình duyệt hoặc công cụ khác.

Làm thế nào để sử dụng Elite Proxies?

Chúng tôi cung cấp hướng dẫn khởi động nhanh dễ hiểu với đầy đủ chi tiết về cách sử dụng và tích hợp. Nếu bạn có bất kỳ câu hỏi nào, vui lòng liên hệ với chúng tôi qua email support@thordata.com!

Elite Proxies hoạt động như thế nào?

Elite proxies hoạt động như một trung gian giữa bạn và trang web đích, giúp ẩn địa chỉ IP thực của bạn. Khi bạn truy cập một trang web, thiết bị của bạn gửi và nhận các tiêu đề HTTP có chứa thông tin về trình duyệt, ngôn ngữ và các cài đặt khác.

Một tính năng quan trọng của elite proxies là khả năng loại bỏ các tiêu đề có thể tiết lộ danh tính của bạn. Ví dụ, tiêu đề "X-Forwarded-For" trong yêu cầu HTTP thường hiển thị IP thực của người dùng, nhưng elite proxies sẽ thay thế bằng địa chỉ IP của máy chủ proxy.

Nhiều câu hỏi

Mua Proxy Cao Cấp. Nhận hiệu suất cao với khả năng bảo vệ quyền riêng tư cao nhất với mức giá chiết khấu.

Chat with usLiveChat