Nền tảng nhận diện tài khoản liên quan như thế nào?

Nền tảng có thể xét tính nhất quán của IP, tín hiệu trình duyệt và thiết bị, vị trí đăng nhập và hoạt động tài khoản. Proxy chỉ quản lý tầng mạng, không thay thế việc vận hành tài khoản có trách nhiệm.

Loại proxy nào phù hợp nhất cho quản lý nhiều tài khoản?

Dùng proxy Static ISP cho vận hành dài hạn, phiên sticky dân cư cho tác vụ tạm thời và proxy di động khi thực sự cần mạng nhà mạng di động.

Một IP có thể dùng cho nhiều tài khoản trên các nền tảng khác nhau không?

Về mặt kỹ thuật là có, nhưng môi trường tách biệt và nhất quán sẽ dễ tổ chức và kiểm tra hơn. Luôn tuân thủ điều khoản của từng nền tảng.

Static ISP và proxy dân cư khác nhau thế nào?

Proxy Static ISP cung cấp IP riêng và cố định. Proxy dân cư có pool xoay lớn hơn, kèm tùy chọn phiên sticky tối đa 90 phút.

Tôi có thể đổi IP được gán cho tài khoản không?

Có, nhưng thay đổi vị trí hoặc IP không cần thiết có thể kích hoạt xác minh bổ sung. Hãy giữ kết nối nhất quán trừ khi có lý do vận hành.

Bạn chịu trách nhiệm chỉ quản lý những tài khoản bạn sở hữu hoặc được ủy quyền vận hành, đồng thời tuân thủ pháp luật hiện hành và điều khoản nền tảng.

Quản lý nhiều tài khoản với IP proxy riêng

          
          import requests
        
          username = "USERNAME"
        
          password = "PASSWORD"
        
          proxy = "user.pr.thordata.com:9999"
        
          proxies = {
        
              'http': f'http://{username}:{password}@{proxy}',
        
              'https': f'http://{username}:{password}@{proxy}'
        
          }
        
          response = requests.request(
        
              'GET',
        
              'https://ipinfo.thordata.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.thordata.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.thordata.com',
        
              proxies=proxies,
        
          )
        
          print(response.text)

          
          import requests
        
          username = "USERNAME"
        
          password = "PASSWORD"
        
          proxy = "unlimited.thordata.com:9999"
        
          proxies = {
        
              'http': f'http://{username}:{password}@{proxy}',
        
              'https': f'http://{username}:{password}@{proxy}'
        
          }
        
          response = requests.request(
        
              'GET',
        
              'https://ipinfo.thordata.com',
        
              proxies=proxies,
        
          )
        
          print(response.text)

          
          import requests
        
          username = "USERNAME"
        
          password = "PASSWORD"
        
          proxy = "user.pr.thordata.com:5555"
        
          proxies = {
        
              'http': f'http://{username}:{password}@{proxy}',
        
              'https': f'http://{username}:{password}@{proxy}'
        
          }
        
          response = requests.request(
        
              'GET',
        
              'https://ipinfo.thordata.com',
        
              proxies=proxies,
        
          )
        
          print(response.text)

          
          import requests
        
          import json
        
          def main():
        
            client = requests.Session()
        
            target_url = "https://scraperapi.thordata.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.thordata.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.thordata.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.thordata.com:9999 -U "td-customer-USERNAME:PASSWORD" https://ipinfo.thordata.com
        

          
          curl -x IP:PORT -U "td-customer-USERNAME:PASSWORD" https://ipinfo.thordata.com
        

          
          curl -x IP:PORT -U "td-customer-USERNAME:PASSWORD" https://ipinfo.thordata.com
        

          
          curl -x unlimited.thordata.com:9999 -U "td-customer-USERNAME:PASSWORD" https://ipinfo.thordata.com
        

          
          curl -x user.pr.thordata.com:5555 -U "td-customer-USERNAME:PASSWORD" https://ipinfo.thordata.com
        

          
          curl -X POST "https://scraperapi.thordata.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.thordata.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.thordata.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.thordata.com:9999';
        
          const agent = createHttpsProxyAgent(
        
            `http://${username}:${password}@${proxy}`
        
          );
        
          const response = await fetch('https://ipinfo.thordata.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.thordata.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.thordata.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.thordata.com:9999';
        
          const agent = createHttpsProxyAgent(
        
            `http://${username}:${password}@${proxy}`
        
          );
        
          const response = await fetch('https://ipinfo.thordata.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.thordata.com:5555';
        
          const agent = createHttpsProxyAgent(
        
            `http://${username}:${password}@${proxy}`
        
          );
        
          const response = await fetch('https://ipinfo.thordata.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.thordata.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.thordata.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.thordata.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.thordata.com:9999';
        
          $query = curl_init('https://ipinfo.thordata.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.thordata.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.thordata.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.thordata.com:9999';
        
          $query = curl_init('https://ipinfo.thordata.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.thordata.com:5555';
        
          $query = curl_init('https://ipinfo.thordata.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.thordata.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.thordata.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.thordata.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.thordata.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.thordata.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.thordata.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.thordata.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.thordata.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.thordata.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.thordata.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.thordata.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.thordata.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.thordata.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.thordata.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.thordata.com";
        
              int proxyPort = 9999;
        
              HttpHost entry = new HttpHost(proxyHost, proxyPort);
        
              String query = Executor.newInstance()
        
                  .auth(entry, username, password)
        
                  .execute(Request.Get("https://ipinfo.thordata.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.thordata.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.thordata.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.thordata.com";
        
              int proxyPort = 9999;
        
              HttpHost entry = new HttpHost(proxyHost, proxyPort);
        
              String query = Executor.newInstance()
        
                  .auth(entry, username, password)
        
                  .execute(Request.Get("https://ipinfo.thordata.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.thordata.com";
        
              int proxyPort = 5555;
        
              HttpHost entry = new HttpHost(proxyHost, proxyPort);
        
              String query = Executor.newInstance()
        
                  .auth(entry, username, password)
        
                  .execute(Request.Get("https://ipinfo.thordata.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.thordata.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.thordata.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.thordata.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.thordata.com:9999";
        
              var client = new WebClient();
        
              client.Proxy = new WebProxy(proxy);
        
              client.Proxy.Credentials = new NetworkCredential(username, password);
        
              Console.WriteLine(client.DownloadString("https://ipinfo.thordata.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.thordata.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.thordata.com"));
        
            }
        
          }

          
          using System;
        
          using System.Net;
        
          class Example
        
          {
        
            static void Main()
        
            {  
        
              var username = "td-customer-USERNAME";
        
              var password = "PASS";
        
              var proxy = "unlimited.thordata.com:9999";
        
              var client = new WebClient();
        
              client.Proxy = new WebProxy(proxy);
        
              client.Proxy.Credentials = new NetworkCredential(username, password);
        
              Console.WriteLine(client.DownloadString("https://ipinfo.thordata.com"));
        
            }
        
          }

          
          using System;
        
          using System.Net;
        
          class Example
        
          {
        
            static void Main()
        
            {  
        
              var username = "td-customer-USERNAME";
        
              var password = "PASS";
        
              var proxy = "user.pr.thordata.com:5555";
        
              var client = new WebClient();
        
              client.Proxy = new WebProxy(proxy);
        
              client.Proxy.Credentials = new NetworkCredential(username, password);
        
              Console.WriteLine(client.DownloadString("https://ipinfo.thordata.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.thordata.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.thordata.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.thordata.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());
        
              }
        
          }

Bộ dữ liệu video

API dữ liệu video

Proxy băng thông cao

Tập dữ liệu đa phương thức

Thordata MCP

Tích hợp n8n

Tích hợp LangChain

Tích hợp LlamaIndex

Tích hợp Dify

Proxy ổn định cho quản lý nhiều tài khoản

Vì sao nên dùng IP riêng cho quản lý nhiều tài khoản?

Tách biệt môi trường mỗi tài khoản

Duy trì truy cập nhất quán cho đội ngũ

Vận hành tài khoản ở nhiều thị trường

Dành cho vận hành tài khoản thực tế

Vận hành cửa hàng Amazon

Cửa hàng Shopify theo khu vực

Quy trình người bán eBay

Cửa hàng Etsy theo danh mục

Agency mạng xã hội

Chọn proxy phù hợp

Cách hoạt động

Chọn khu vực

Gán kết nối proxy

Kết nối hồ sơ trình duyệt riêng

Tương thích với công cụ quản lý tài khoản hiện có

Xây dựng cấu hình đa tài khoản nhất quán hơn

Câu hỏi thường gặp