Residential Proxies

          1
          import requests
        

          2
          
        

          3
          username = "USERNAME"
        

          4
          password = "PASSWORD"
        

          5
          proxy = "user.pr.thordata.net:9999"
        

          6
          
        

          7
          proxies = {
        

          8
              'http': f'http://{username}:{password}@{proxy}',
        

          9
              'https': f'http://{username}:{password}@{proxy}'
        

          10
          }
        

          11
          
        

          12
          response = requests.request(
        

          13
              'GET',
        

          14
              'https://ipinfo.thordata.com',
        

          15
              proxies=proxies,
        

          16
          )
        

          17
          
        

          18
          print(response.text)
        

          1
          import requests
        

          2
          
        

          3
          username = "USERNAME"
        

          4
          password = "PASSWORD"
        

          5
          proxy = "IP:PORT"
        

          6
          
        

          7
          proxies = {
        

          8
              'http': f'http://{username}:{password}@{proxy}',
        

          9
              'https': f'http://{username}:{password}@{proxy}'
        

          10
          }
        

          11
          
        

          12
          response = requests.request(
        

          13
              'GET',
        

          14
              'https://ipinfo.thordata.com',
        

          15
              proxies=proxies,
        

          16
          )
        

          17
          
        

          18
          print(response.text)
        

          1
          import requests
        

          2
          
        

          3
          username = "USERNAME"
        

          4
          password = "PASSWORD"
        

          5
          proxy = "IP:PORT"
        

          6
          
        

          7
          proxies = {
        

          8
              'http': f'http://{username}:{password}@{proxy}',
        

          9
              'https': f'http://{username}:{password}@{proxy}'
        

          10
          }
        

          11
          
        

          12
          response = requests.request(
        

          13
              'GET',
        

          14
              'https://ipinfo.thordata.com',
        

          15
              proxies=proxies,
        

          16
          )
        

          17
          
        

          18
          print(response.text)
        

          1
          import requests
        

          2
          
        

          3
          username = "USERNAME"
        

          4
          password = "PASSWORD"
        

          5
          proxy = "unlimited.thordata.net:9999"
        

          6
          
        

          7
          proxies = {
        

          8
              'http': f'http://{username}:{password}@{proxy}',
        

          9
              'https': f'http://{username}:{password}@{proxy}'
        

          10
          }
        

          11
          
        

          12
          response = requests.request(
        

          13
              'GET',
        

          14
              'https://ipinfo.thordata.com',
        

          15
              proxies=proxies,
        

          16
          )
        

          17
          
        

          18
          print(response.text)
        

          1
          import requests
        

          2
          
        

          3
          username = "USERNAME"
        

          4
          password = "PASSWORD"
        

          5
          proxy = "user.pr.thordata.net:5555"
        

          6
          
        

          7
          proxies = {
        

          8
              'http': f'http://{username}:{password}@{proxy}',
        

          9
              'https': f'http://{username}:{password}@{proxy}'
        

          10
          }
        

          11
          
        

          12
          response = requests.request(
        

          13
              'GET',
        

          14
              'https://ipinfo.thordata.com',
        

          15
              proxies=proxies,
        

          16
          )
        

          17
          
        

          18
          print(response.text)
        

          1
          import requests
        

          2
          import json
        

          3
          
        

          4
          def main():
        

          5
            client = requests.Session()
        

          6
            target_url = "https://scraperapi.thordata.com/builder"
        

          7
          
        

          8
            spider_parameters = [
        

          9
              {
        

          10
                "url": "https://www.youtube.com/@stephcurry/videos",
        

          11
                "order_by": "",
        

          12
                "num_of_posts": ""
        

          13
              }
        

          14
            ]
        

          15
          
        

          16
            spider_parameters_json = json.dumps(spider_parameters)
        

          17
            
        

          18
            form_data = {
        

          19
              "spider_name": "youtube.com",
        

          20
              "spider_id": "youtube_video-post_by-url",
        

          21
              "spider_parameters": spider_parameters_json,
        

          22
              "spider_errors": "true",
        

          23
              "file_name": "{{VideoID}}"
        

          24
            }
        

          25
          
        

          26
            headers = {
        

          27
              "Authorization": "Bearer Token",
        

          28
              "Content-Type": "application/x-www-form-urlencoded"
        

          29
            }
        

          30
          
        

          31
            try:
        

          32
              resp = client.post(target_url, data=form_data, headers=headers)
        

          33
              resp.raise_for_status()  # Raises an HTTPError for bad responses
        

          34
              
        

          35
              print(f"Status Code: {resp.status_code}")
        

          36
              print(f"Response Body: {resp.text}")
        

          37
                
        

          38
            except requests.exceptions.RequestException as e:
        

          39
              print(f"Error sending request: {e}")
        

          40
          
        

          41
          if __name__ == "__main__":
        

          42
            main()
        

          1
          import http.client
        

          2
          from urllib.parse import urlencode
        

          3
          
        

          4
          conn = http.client.HTTPSConnection("webunlocker.thordata.com")
        

          5
          
        

          6
          payload = {
        

          7
              "url": "https://www.google.com",
        

          8
              "type": "html",
        

          9
              "js_render": "True"
        

          10
          }
        

          11
          
        

          12
          form_data = urlencode(payload)
        

          13
          
        

          14
          headers = {
        

          15
              'Authorization': "Bearer Token",
        

          16
              'content-type': "application/x-www-form-urlencoded"
        

          17
          }
        

          18
          
        

          19
          conn.request("POST", "/request", form_data, headers)
        

          20
          
        

          21
          res = conn.getresponse()
        

          22
          data = res.read()
        

          23
          
        

          24
          print(f"Status: {res.status} {res.reason}")
        

          25
          print(data.decode("utf-8"))
        

          1
          import http.client 
        

          2
          from urllib.parse import urlencode
        

          3
          conn = http.client.HTTPSConnection("scraperapi.thordata.com")
        

          4
          params = {
        

          5
                  "engine": "google",
        

          6
                  "q": "pizza",
        

          7
                  "json": "1"
        

          8
                }
        

          9
          payload = urlencode(params) 
        

          10
          
        

          11
          headers = { 
        

          12
            'Authorization': 'Bearer Token',
        

          13
            'Content-Type': 'application/x-www-form-urlencoded'
        

          14
          }
        

          15
          
        

          16
          conn.request("POST", "/request", payload, headers) 
        

          17
          res = conn.getresponse() 
        

          18
          data = res.read() 
        

          19
          print(data.decode("utf-8"))
        

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

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

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

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

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

          1
          curl -X POST "https://scraperapi.thordata.com/builder" \
        

          2
            -H "Authorization: Bearer Token" \
        

          3
            -H "Content-Type: application/x-www-form-urlencoded" \
        

          4
            -d "spider_name=youtube.com" \
        

          5
            -d "spider_id=youtube_video-post_by-url" \
        

          6
            -d "spider_parameters=[{\"url\": \"https://www.youtube.com/@stephcurry/videos\",\"order_by\": \"\",\"num_of_posts\": \"\"}]" \
        

          7
            -d "spider_errors=true" \
        

          8
            -d "file_name={{VideoID}}"
        

          1
          curl -X POST https://webunlocker.thordata.com/request \
        

          2
           -H "Authorization: Bearer Token" \
        

          3
           -H "Content-Type: application/x-www-form-urlencoded" \
        

          4
           -d "url=https://www.google.com" \
        

          5
           -d "type=html" \
        

          6
           -d "js_render=True"
        

          1
          curl -X POST https://scraperapi.thordata.com/request \
        

          2
           -H "Content-Type: application/x-www-form-urlencoded" \
        

          3
           -H "Authorization: Bearer Token" \
        

          4
           -d "engine=google" \
        

          5
           -d "q=pizza" \
        

          6
           -d "json=1"
        

          1
          import fetch from 'node-fetch';
        

          2
          import createHttpsProxyAgent from 'https-proxy-agent';
        

          3
          
        

          4
          const username = 'td-customer-USERNAME';
        

          5
          const password = 'PASS';
        

          6
          const proxy = 'user.pr.thordata.net:9999';
        

          7
          
        

          8
          const agent = createHttpsProxyAgent(
        

          9
            `http://${username}:${password}@${proxy}`
        

          10
          );
        

          11
          
        

          12
          const response = await fetch('https://ipinfo.thordata.com', {
        

          13
            method: 'get',
        

          14
            agent: agent,
        

          15
          });
        

          16
          
        

          17
          console.log(await response.text());
        

          1
          import fetch from 'node-fetch';
        

          2
          import createHttpsProxyAgent from 'https-proxy-agent';
        

          3
          
        

          4
          const username = 'td-customer-USERNAME';
        

          5
          const password = 'PASS';
        

          6
          const proxy = 'IP:PORT';
        

          7
          
        

          8
          const agent = createHttpsProxyAgent(
        

          9
            `http://${username}:${password}@${proxy}`
        

          10
          );
        

          11
          
        

          12
          const response = await fetch('https://ipinfo.thordata.com', {
        

          13
            method: 'get',
        

          14
            agent: agent,
        

          15
          });
        

          16
          
        

          17
          console.log(await response.text());
        

          1
          import fetch from 'node-fetch';
        

          2
          import createHttpsProxyAgent from 'https-proxy-agent';
        

          3
          
        

          4
          const username = 'td-customer-USERNAME';
        

          5
          const password = 'PASS';
        

          6
          const proxy = 'IP:PORT';
        

          7
          
        

          8
          const agent = createHttpsProxyAgent(
        

          9
            `http://${username}:${password}@${proxy}`
        

          10
          );
        

          11
          
        

          12
          const response = await fetch('https://ipinfo.thordata.com', {
        

          13
            method: 'get',
        

          14
            agent: agent,
        

          15
          });
        

          16
          
        

          17
          console.log(await response.text());
        

          1
          import fetch from 'node-fetch';
        

          2
          import createHttpsProxyAgent from 'https-proxy-agent';
        

          3
          
        

          4
          const username = 'td-customer-USERNAME';
        

          5
          const password = 'PASS';
        

          6
          const proxy = 'unlimited.thordata.net:9999';
        

          7
          
        

          8
          const agent = createHttpsProxyAgent(
        

          9
            `http://${username}:${password}@${proxy}`
        

          10
          );
        

          11
          
        

          12
          const response = await fetch('https://ipinfo.thordata.com', {
        

          13
            method: 'get',
        

          14
            agent: agent,
        

          15
          });
        

          16
          
        

          17
          console.log(await response.text());
        

          1
          import fetch from 'node-fetch';
        

          2
          import createHttpsProxyAgent from 'https-proxy-agent';
        

          3
          
        

          4
          const username = 'td-customer-USERNAME';
        

          5
          const password = 'PASS';
        

          6
          const proxy = 'user.pr.thordata.net:5555';
        

          7
          
        

          8
          const agent = createHttpsProxyAgent(
        

          9
            `http://${username}:${password}@${proxy}`
        

          10
          );
        

          11
          
        

          12
          const response = await fetch('https://ipinfo.thordata.com', {
        

          13
            method: 'get',
        

          14
            agent: agent,
        

          15
          });
        

          16
          
        

          17
          console.log(await response.text());
        

          1
          const axios = require('axios');
        

          2
          const qs = require('querystring');
        

          3
          
        

          4
          async function main() {
        

          5
            const targetURL = "https://scraperapi.thordata.com/builder";
        

          6
          
        

          7
            const spiderInfo = [
        

          8
              {
        

          9
                "url": "https://www.youtube.com/@stephcurry/videos",
        

          10
                "order_by": "",
        

          11
                "num_of_posts": ""
        

          12
              }
        

          13
            ];
        

          14
            
        

          15
            try {
        

          16
              const spiderInfoJSON = JSON.stringify(spiderInfo);
        

          17
              
        

          18
              const formData = qs.stringify({
        

          19
                spider_name: "youtube.com",
        

          20
                spider_id: "youtube_video-post_by-url",
        

          21
                spider_parameters: spiderInfoJSON,
        

          22
                spider_errors: true,
        

          23
                file_name: "{{VideoID}}"
        

          24
              });
        

          25
          
        

          26
              const response = await axios.post(targetURL, formData, {
        

          27
                headers: {
        

          28
                  'Authorization': 'Bearer Token',
        

          29
                  'Content-Type': 'application/x-www-form-urlencoded'
        

          30
                }
        

          31
              });
        

          32
          
        

          33
              console.log(`Status Code: ${response.status}`);
        

          34
              console.log(`Response Body: ${JSON.stringify(response.data)}`);
        

          35
            } catch (error) {
        

          36
              if (error.response) {
        

          37
                console.error(`Error response: ${error.response.status} - ${error.response.data}`);
        

          38
              } else if (error.request) {
        

          39
                console.error('No response received:', error.request);
        

          40
              } else {
        

          41
                console.error('Error:', error.message);
        

          42
              }
        

          43
            }
        

          44
          }
        

          45
          
        

          46
          main();
        

          1
          const https = require("https");
        

          2
          const querystring = require("querystring"); 
        

          3
          
        

          4
          const options = {
        

          5
              method: "POST",
        

          6
              hostname: "webunlocker.thordata.com",
        

          7
              path: "/request",
        

          8
              headers: {
        

          9
                  "Authorization": "Bearer Token",
        

          10
                  "content-type": "application/x-www-form-urlencoded" 
        

          11
              }
        

          12
          };
        

          13
          const formData = {
        

          14
              url: "https://www.google.com",
        

          15
              type: "html",
        

          16
              js_render: "True"
        

          17
          };
        

          18
          
        

          19
          const formDataString = querystring.stringify(formData);
        

          20
          options.headers["Content-Length"] = formDataString.length;
        

          21
          
        

          22
          const req = https.request(options, (res) => {
        

          23
              const chunks = [];
        

          24
              res.on("data", (chunk) => chunks.push(chunk));
        

          25
              res.on("end", () => {
        

          26
                  const body = Buffer.concat(chunks);
        

          27
                  console.log(body.toString());
        

          28
              });
        

          29
          });
        

          30
          
        

          31
          req.write(formDataString);
        

          32
          req.end();
        

          1
          const axios = require('axios');
        

          2
          
        

          3
          const params = new URLSearchParams({
        

          4
                  engine: 'google',
        

          5
                  q: 'pizza',
        

          6
                  json: '1'
        

          7
          });
        

          8
          
        

          9
          const config = {
        

          10
              method: 'post',
        

          11
              url: 'https://scraperapi.thordata.com/request',
        

          12
              headers: { 
        

          13
                  Authorization: 'Bearer Token',
        

          14
                  'Content-Type': 'application/x-www-form-urlencoded'
        

          15
              },
        

          16
              data: params
        

          17
          };
        

          18
          
        

          19
          axios.request(config)
        

          20
              .then((response) => {
        

          21
                  console.log(JSON.stringify(response.data));
        

          22
              })
        

          23
              .catch((error) => {
        

          24
                  console.log(error);
        

          25
          });
        

          1
          <?php
        

          2
          
        

          3
          $username = 'td-customer-USERNAME';
        

          4
          $password = 'PASS';
        

          5
          $proxy = 'user.pr.thordata.net:9999';
        

          6
          
        

          7
          $query = curl_init('https://ipinfo.thordata.com');
        

          8
          
        

          9
          curl_setopt($query, CURLOPT_RETURNTRANSFER, 1);
        

          10
          curl_setopt($query, CURLOPT_PROXY, "http://$proxy");
        

          11
          curl_setopt($query, CURLOPT_PROXYUSERPWD, "$username:$password");
        

          12
          
        

          13
          $output = curl_exec($query);
        

          14
          curl_close($query);
        

          15
          if ($output)
        

          16
              echo $output;
        

          17
          ?>
        

          1
          <?php
        

          2
          
        

          3
          $username = 'td-customer-USERNAME';
        

          4
          $password = 'PASS';
        

          5
          $proxy = 'IP:PORT';
        

          6
          
        

          7
          $query = curl_init('https://ipinfo.thordata.com');
        

          8
          
        

          9
          curl_setopt($query, CURLOPT_RETURNTRANSFER, 1);
        

          10
          curl_setopt($query, CURLOPT_PROXY, "http://$proxy");
        

          11
          curl_setopt($query, CURLOPT_PROXYUSERPWD, "$username:$password");
        

          12
          
        

          13
          $output = curl_exec($query);
        

          14
          curl_close($query);
        

          15
          if ($output)
        

          16
              echo $output;
        

          17
          ?>
        

          1
          <?php
        

          2
          
        

          3
          $username = 'td-customer-USERNAME';
        

          4
          $password = 'PASS';
        

          5
          $proxy = 'IP:PORT';
        

          6
          
        

          7
          $query = curl_init('https://ipinfo.thordata.com');
        

          8
          
        

          9
          curl_setopt($query, CURLOPT_RETURNTRANSFER, 1);
        

          10
          curl_setopt($query, CURLOPT_PROXY, "http://$proxy");
        

          11
          curl_setopt($query, CURLOPT_PROXYUSERPWD, "$username:$password");
        

          12
          
        

          13
          $output = curl_exec($query);
        

          14
          curl_close($query);
        

          15
          if ($output)
        

          16
              echo $output;
        

          17
          ?>
        

          1
          <?php
        

          2
          
        

          3
          $username = 'td-customer-USERNAME';
        

          4
          $password = 'PASS';
        

          5
          $proxy = 'unlimited.thordata.net:9999';
        

          6
          
        

          7
          $query = curl_init('https://ipinfo.thordata.com');
        

          8
          
        

          9
          curl_setopt($query, CURLOPT_RETURNTRANSFER, 1);
        

          10
          curl_setopt($query, CURLOPT_PROXY, "http://$proxy");
        

          11
          curl_setopt($query, CURLOPT_PROXYUSERPWD, "$username:$password");
        

          12
          
        

          13
          $output = curl_exec($query);
        

          14
          curl_close($query);
        

          15
          if ($output)
        

          16
              echo $output;
        

          17
          ?>
        

          1
          <?php
        

          2
          
        

          3
          $username = 'td-customer-USERNAME';
        

          4
          $password = 'PASS';
        

          5
          $proxy = 'user.pr.thordata.net:5555';
        

          6
          
        

          7
          $query = curl_init('https://ipinfo.thordata.com');
        

          8
          
        

          9
          curl_setopt($query, CURLOPT_RETURNTRANSFER, 1);
        

          10
          curl_setopt($query, CURLOPT_PROXY, "http://$proxy");
        

          11
          curl_setopt($query, CURLOPT_PROXYUSERPWD, "$username:$password");
        

          12
          
        

          13
          $output = curl_exec($query);
        

          14
          curl_close($query);
        

          15
          if ($output)
        

          16
              echo $output;
        

          17
          ?>
        

          1
          <?php
        

          2
          
        

          3
          $targetURL = "https://scraperapi.thordata.com/builder";
        

          4
          
        

          5
          $spiderInfo = [
        

          6
            [
        

          7
              "url" => "https://www.youtube.com/@stephcurry/videos",
        

          8
              "order_by" => "",
        

          9
              "num_of_posts" => ""
        

          10
            ]
        

          11
          ];
        

          12
          
        

          13
          $spiderInfoJSON = json_encode($spiderInfo);
        

          14
          if ($spiderInfoJSON === false) {
        

          15
            die("Error marshaling JSON: " . json_last_error_msg());
        

          16
          }
        

          17
          
        

          18
          $formData = [
        

          19
            "spider_name" => "youtube.com",
        

          20
            "spider_id" => "youtube_video-post_by-url",
        

          21
            "spider_parameters" => $spiderInfoJSON,
        

          22
            "spider_errors" => true,
        

          23
            "file_name" => "{{VideoID}}"
        

          24
          ];
        

          25
          
        

          26
          $options = [
        

          27
            "http" => [
        

          28
              "method" => "POST",
        

          29
              "header" => implode("\r\n", [
        

          30
                "Authorization: Bearer Token",
        

          31
                "Content-Type: application/x-www-form-urlencoded",
        

          32
                "Accept: application/json"
        

          33
              ]),
        

          34
              "content" => http_build_query($formData)
        

          35
            ]
        

          36
          ];
        

          37
          
        

          38
          $context = stream_context_create($options);
        

          39
          $response = file_get_contents($targetURL, false, $context);
        

          40
          
        

          41
          if ($response === false) {
        

          42
            $error = error_get_last();
        

          43
            die("Error sending request: " . $error["message"]);
        

          44
          }
        

          45
          
        

          46
          // Get HTTP status code
        

          47
          $statusCode = null;
        

          48
          if (isset($http_response_header[0])) {
        

          49
            preg_match('/HTTP\/\d\.\d (\d{3})/', $http_response_header[0], $matches);
        

          50
            $statusCode = $matches[1] ?? null;
        

          51
          }
        

          52
          
        

          53
          echo "Status Code: " . $statusCode . "\n";
        

          54
          echo "Response Body: " . $response . "\n";
        

          55
          ?>
        

          1
          <?php
        

          2
          $data = [
        

          3
              'url'=> 'https://www.google.com',
        

          4
              'type'=> 'html',
        

          5
              'js_render'=> 'True'
        

          6
          ];
        

          7
          
        

          8
          $queryString = http_build_query($data);
        

          9
          
        

          10
          $curl = curl_init();
        

          11
          curl_setopt_array($curl, [
        

          12
              CURLOPT_URL => "https://webunlocker.thordata.com/request",
        

          13
              CURLOPT_RETURNTRANSFER => true,
        

          14
              CURLOPT_ENCODING => "",
        

          15
              CURLOPT_MAXREDIRS => 10,
        

          16
              CURLOPT_TIMEOUT => 30,
        

          17
              CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
        

          18
              CURLOPT_CUSTOMREQUEST => "POST",
        

          19
          CURLOPT_POSTFIELDS => $queryString, 
        

          20
          CURLOPT_HTTPHEADER => [
        

          21
                  "Authorization: Bearer Token",
        

          22
                  "content-type: application/x-www-form-urlencoded" 
        

          23
              ],
        

          24
          ]);
        

          25
          $response = curl_exec($curl);
        

          26
          $err = curl_error($curl);
        

          27
          curl_close($curl);
        

          28
          if ($err) {
        

          29
              echo "cURL Error #:" . $err;
        

          30
          } else {
        

          31
              echo $response;
        

          32
          }
        

          33
          ?>
        

          1
          <?php
        

          2
          $curl = curl_init();
        

          3
          
        

          4
          $data = [
        

          5
                  "engine" => "google",
        

          6
                  "q" => "pizza",
        

          7
                  "json" => "1"
        

          8
          ];
        

          9
          
        

          10
          curl_setopt_array($curl, array(
        

          11
              CURLOPT_URL => 'https://scraperapi.thordata.com/request',
        

          12
              CURLOPT_RETURNTRANSFER => true,
        

          13
              CURLOPT_ENCODING => '',
        

          14
              CURLOPT_MAXREDIRS => 10,
        

          15
              CURLOPT_TIMEOUT => 0,
        

          16
              CURLOPT_FOLLOWLOCATION => true,
        

          17
              CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
        

          18
              CURLOPT_CUSTOMREQUEST => 'POST',
        

          19
              CURLOPT_POSTFIELDS => http_build_query($data),
        

          20
              CURLOPT_HTTPHEADER => array(
        

          21
                  'Authorization: Bearer Token',
        

          22
                  'Content-Type: application/x-www-form-urlencoded'
        

          23
              ),
        

          24
          ));
        

          25
          
        

          26
          $response = curl_exec($curl);
        

          27
          curl_close($curl);
        

          28
          echo $response;
        

          29
          ?>
        

          1
          package main
        

          2
          
        

          3
          import (
        

          4
            "fmt"
        

          5
            "io/ioutil"
        

          6
            "net/http"
        

          7
            "net/url"
        

          8
          )
        

          9
          
        

          10
          func main() {
        

          11
            const username = "td-customer-USERNAME"
        

          12
            const password = "PASS"
        

          13
            const proxy = "user.pr.thordata.net:9999"
        

          14
          
        

          15
            proxyUrl, _ := url.Parse(
        

          16
              fmt.Sprintf(
        

          17
                "http://%s:%s@%s",
        

          18
                username,
        

          19
                password,
        

          20
                proxy,
        

          21
              ),
        

          22
            )
        

          23
          
        

          24
            client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}
        

          25
          
        

          26
            request, _ := http.NewRequest("GET",
        

          27
              "https://ipinfo.thordata.com",
        

          28
              nil,
        

          29
            )
        

          30
          
        

          31
            request.SetBasicAuth(username, password)
        

          32
            response, err := client.Do(request)
        

          33
            if err != nil {
        

          34
              fmt.Println(err)
        

          35
              return
        

          36
            }
        

          37
          
        

          38
            responseText, _ := ioutil.ReadAll(response.Body)
        

          39
            fmt.Println(string(responseText))
        

          40
          }
        

          1
          package main
        

          2
          
        

          3
          import (
        

          4
            "fmt"
        

          5
            "io/ioutil"
        

          6
            "net/http"
        

          7
            "net/url"
        

          8
          )
        

          9
          
        

          10
          func main() {
        

          11
            const username = "td-customer-USERNAME"
        

          12
            const password = "PASS"
        

          13
            const proxy = "IP:PORT"
        

          14
          
        

          15
            proxyUrl, _ := url.Parse(
        

          16
              fmt.Sprintf(
        

          17
                "http://%s:%s@%s",
        

          18
                username,
        

          19
                password,
        

          20
                proxy,
        

          21
              ),
        

          22
            )
        

          23
          
        

          24
            client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}
        

          25
          
        

          26
            request, _ := http.NewRequest("GET",
        

          27
              "https://ipinfo.thordata.com",
        

          28
              nil,
        

          29
            )
        

          30
          
        

          31
            request.SetBasicAuth(username, password)
        

          32
            response, err := client.Do(request)
        

          33
            if err != nil {
        

          34
              fmt.Println(err)
        

          35
              return
        

          36
            }
        

          37
          
        

          38
            responseText, _ := ioutil.ReadAll(response.Body)
        

          39
            fmt.Println(string(responseText))
        

          40
          }
        

          1
          package main
        

          2
          
        

          3
          import (
        

          4
            "fmt"
        

          5
            "io/ioutil"
        

          6
            "net/http"
        

          7
            "net/url"
        

          8
          )
        

          9
          
        

          10
          func main() {
        

          11
            const username = "td-customer-USERNAME"
        

          12
            const password = "PASS"
        

          13
            const proxy = "IP:PORT"
        

          14
          
        

          15
            proxyUrl, _ := url.Parse(
        

          16
              fmt.Sprintf(
        

          17
                "http://%s:%s@%s",
        

          18
                username,
        

          19
                password,
        

          20
                proxy,
        

          21
              ),
        

          22
            )
        

          23
          
        

          24
            client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}
        

          25
          
        

          26
            request, _ := http.NewRequest("GET",
        

          27
              "https://ipinfo.thordata.com",
        

          28
              nil,
        

          29
            )
        

          30
          
        

          31
            request.SetBasicAuth(username, password)
        

          32
            response, err := client.Do(request)
        

          33
            if err != nil {
        

          34
              fmt.Println(err)
        

          35
              return
        

          36
            }
        

          37
          
        

          38
            responseText, _ := ioutil.ReadAll(response.Body)
        

          39
            fmt.Println(string(responseText))
        

          40
          }
        

          1
          package main
        

          2
          
        

          3
          import (
        

          4
            "fmt"
        

          5
            "io/ioutil"
        

          6
            "net/http"
        

          7
            "net/url"
        

          8
          )
        

          9
          
        

          10
          func main() {
        

          11
            const username = "td-customer-USERNAME"
        

          12
            const password = "PASS"
        

          13
            const proxy = "unlimited.thordata.net:9999"
        

          14
          
        

          15
            proxyUrl, _ := url.Parse(
        

          16
              fmt.Sprintf(
        

          17
                "http://%s:%s@%s",
        

          18
                username,
        

          19
                password,
        

          20
                proxy,
        

          21
              ),
        

          22
            )
        

          23
          
        

          24
            client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}
        

          25
          
        

          26
            request, _ := http.NewRequest("GET",
        

          27
              "https://ipinfo.thordata.com",
        

          28
              nil,
        

          29
            )
        

          30
          
        

          31
            request.SetBasicAuth(username, password)
        

          32
            response, err := client.Do(request)
        

          33
            if err != nil {
        

          34
              fmt.Println(err)
        

          35
              return
        

          36
            }
        

          37
          
        

          38
            responseText, _ := ioutil.ReadAll(response.Body)
        

          39
            fmt.Println(string(responseText))
        

          40
          }
        

          1
          package main
        

          2
          
        

          3
          import (
        

          4
            "fmt"
        

          5
            "io/ioutil"
        

          6
            "net/http"
        

          7
            "net/url"
        

          8
          )
        

          9
          
        

          10
          func main() {
        

          11
            const username = "td-customer-USERNAME"
        

          12
            const password = "PASS"
        

          13
            const proxy = "user.pr.thordata.net:5555"
        

          14
          
        

          15
            proxyUrl, _ := url.Parse(
        

          16
              fmt.Sprintf(
        

          17
                "http://%s:%s@%s",
        

          18
                username,
        

          19
                password,
        

          20
                proxy,
        

          21
              ),
        

          22
            )
        

          23
          
        

          24
            client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}
        

          25
          
        

          26
            request, _ := http.NewRequest("GET",
        

          27
              "https://ipinfo.thordata.com",
        

          28
              nil,
        

          29
            )
        

          30
          
        

          31
            request.SetBasicAuth(username, password)
        

          32
            response, err := client.Do(request)
        

          33
            if err != nil {
        

          34
              fmt.Println(err)
        

          35
              return
        

          36
            }
        

          37
          
        

          38
            responseText, _ := ioutil.ReadAll(response.Body)
        

          39
            fmt.Println(string(responseText))
        

          40
          }
        

          1
          package main
        

          2
          
        

          3
          import (
        

          4
            "encoding/json"
        

          5
            "fmt"
        

          6
            "io"
        

          7
            "net/http"
        

          8
            "net/url"
        

          9
            "strings"
        

          10
          )
        

          11
          
        

          12
          func main() {
        

          13
            client := &http.Client{}
        

          14
            targetURL := "https://scraperapi.thordata.com/builder"
        

          15
          
        

          16
            spiderInfo := []map[string]string{ 
        

          17
              {
        

          18
                "url": "https://www.youtube.com/@stephcurry/videos",
        

          19
                "order_by": "",
        

          20
                "num_of_posts": "",
        

          21
              },
        

          22
            }
        

          23
          
        

          24
            spiderInfoJSON, err := json.Marshal(spiderInfo)
        

          25
            if err != nil {
        

          26
              fmt.Println("Error marshaling JSON:", err)
        

          27
              return
        

          28
            }
        

          29
            
        

          30
            formData := url.Values{}
        

          31
            formData.Add("spider_name", "youtube.com")
        

          32
            formData.Add("spider_id", "youtube_video-post_by-url")
        

          33
            formData.Add("spider_parameters", string(spiderInfoJSON))
        

          34
            formData.Add("spider_errors", "true")
        

          35
            formData.Add("file_name", "{{VideoID}}")
        

          36
            
        

          37
            req, err := http.NewRequest("POST", targetURL, strings.NewReader(formData.Encode()))
        

          38
            if err != nil {
        

          39
              fmt.Println("Error creating request:", err)
        

          40
              return
        

          41
            }
        

          42
          
        

          43
            req.Header.Set("Authorization", "Bearer Token")
        

          44
            req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
        

          45
          
        

          46
            resp, err := client.Do(req)
        

          47
            if err != nil {
        

          48
              fmt.Println("Error sending request:", err)
        

          49
              return
        

          50
            }
        

          51
            defer resp.Body.Close()
        

          52
          
        

          53
            body, err := io.ReadAll(resp.Body)
        

          54
            if err != nil {
        

          55
              fmt.Println("Error reading response:", err)
        

          56
              return
        

          57
            }
        

          58
          
        

          59
            fmt.Printf("Status Code: %d\n", resp.StatusCode)
        

          60
            fmt.Printf("Response Body: %s\n", body)
        

          61
          }
        

          1
          package main
        

          2
          
        

          3
          import (
        

          4
          	"fmt"
        

          5
          	"io/ioutil"
        

          6
          	"log"
        

          7
          	"net/http"
        

          8
          	"net/url"
        

          9
          	"strings"
        

          10
          	"time"
        

          11
          )
        

          12
          
        

          13
          func main() {
        

          14
          	
        

          15
          	var apiKey = "Token"
        

          16
          	var targetURL = "https://webunlocker.thordata.com/request"
        

          17
          	
        

          18
          	formData := url.Values{
        

          19
              "url": {"https://www.google.com"},
        

          20
              "type": {"html"},
        

          21
              "js_render": {"True"},
        

          22
              }
        

          23
          	
        

          24
          	client := &http.Client{Timeout: 30 * time.Second}
        

          25
          	
        

          26
          	req, err := http.NewRequest("POST", targetURL, strings.NewReader(formData.Encode()))
        

          27
          	if err != nil {
        

          28
          		log.Fatal("Create request failed:", err)
        

          29
          	}
        

          30
          	
        

          31
          	req.Header = http.Header{
        

          32
          		"Authorization": {"Bearer " + apiKey},
        

          33
          		"Content-Type":  {"application/x-www-form-urlencoded"},
        

          34
          	}
        

          35
          	
        

          36
          	res, err := client.Do(req)
        

          37
          	if err != nil {
        

          38
          		log.Fatal("Failed to send request:", err)
        

          39
          	}
        

          40
          	defer res.Body.Close()
        

          41
          	
        

          42
          	body, err := ioutil.ReadAll(res.Body)
        

          43
          	if err != nil {
        

          44
          		log.Fatal("Failed to read response:", err)
        

          45
          	}
        

          46
          	
        

          47
          	fmt.Printf("Status: %d Content:%s", res.StatusCode, body)
        

          48
          }
        

          1
          package main
        

          2
          
        

          3
          import (
        

          4
                  "fmt"
        

          5
                  "net/http"
        

          6
                  "net/url"  
        

          7
                  "strings"
        

          8
                  "io"
        

          9
          )
        

          10
          
        

          11
          func main(){
        

          12
                  urlStr := "https://scraperapi.thordata.com/request"
        

          13
                  method := "POST"
        

          14
          
        

          15
                  formData := url.Values{
        

          16
                           "engine": {"google"},
        

          17
                           "q": {"pizza"},
        

          18
                          "json": {"1"},
        

          19
                  }
        

          20
          
        

          21
                  payload := strings.NewReader(formData.Encode())
        

          22
          
        

          23
                  client := &http.Client{}
        

          24
                  req, err := http.NewRequest(method, urlStr, payload)
        

          25
                  if err != nil {
        

          26
                          fmt.Println(err)
        

          27
                                  return
        

          28
                  }
        

          29
          
        

          30
                  req.Header.Add("Authorization", "Bearer Token")
        

          31
          	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")
        

          32
                  res, err := client.Do(req)
        

          33
                  if err != nil {
        

          34
                          fmt.Println(err)
        

          35
                                  return
        

          36
                  }
        

          37
                  defer res.Body.Close()
        

          38
          
        

          39
                  body, err := io.ReadAll(res.Body)
        

          40
                  if err != nil {
        

          41
                          fmt.Println(err)
        

          42
                                  return
        

          43
                  }
        

          44
                  
        

          45
                  fmt.Println(string(body))
        

          46
          }
        

          1
          package example;
        

          2
          
        

          3
          import org.apache.http.HttpHost;
        

          4
          import org.apache.http.client.fluent.*;
        

          5
          
        

          6
          public class Main {
        

          7
          
        

          8
            public static void main(String[] args) throws Exception {
        

          9
          
        

          10
              String username = "td-customer-USERNAME";
        

          11
              String password = "PASS";
        

          12
              String proxyHost = "user.pr.thordata.net";
        

          13
              int proxyPort = 9999;
        

          14
          
        

          15
              HttpHost entry = new HttpHost(proxyHost, proxyPort);
        

          16
              String query = Executor.newInstance()
        

          17
                  .auth(entry, username, password)
        

          18
                  .execute(Request.Get("https://ipinfo.thordata.com")
        

          19
                  .viaProxy(entry))
        

          20
                  .returnContent()
        

          21
                  .asString();
        

          22
              System.out.println(query);
        

          23
            }
        

          24
          }
        

          1
          package example;
        

          2
          
        

          3
          import org.apache.http.HttpHost;
        

          4
          import org.apache.http.client.fluent.*;
        

          5
          
        

          6
          public class Main {
        

          7
          
        

          8
            public static void main(String[] args) throws Exception {
        

          9
          
        

          10
              String username = "td-customer-USERNAME";
        

          11
              String password = "PASS";
        

          12
              String proxyHost = "IP";
        

          13
              int proxyPort = PORT;
        

          14
          
        

          15
              HttpHost entry = new HttpHost(proxyHost, proxyPort);
        

          16
              String query = Executor.newInstance()
        

          17
                  .auth(entry, username, password)
        

          18
                  .execute(Request.Get("https://ipinfo.thordata.com")
        

          19
                  .viaProxy(entry))
        

          20
                  .returnContent()
        

          21
                  .asString();
        

          22
              System.out.println(query);
        

          23
            }
        

          24
          }
        

          1
          package example;
        

          2
          
        

          3
          import org.apache.http.HttpHost;
        

          4
          import org.apache.http.client.fluent.*;
        

          5
          
        

          6
          public class Main {
        

          7
          
        

          8
            public static void main(String[] args) throws Exception {
        

          9
          
        

          10
              String username = "td-customer-USERNAME";
        

          11
              String password = "PASS";
        

          12
              String proxyHost = "IP";
        

          13
              int proxyPort = PORT;
        

          14
          
        

          15
              HttpHost entry = new HttpHost(proxyHost, proxyPort);
        

          16
              String query = Executor.newInstance()
        

          17
                  .auth(entry, username, password)
        

          18
                  .execute(Request.Get("https://ipinfo.thordata.com")
        

          19
                  .viaProxy(entry))
        

          20
                  .returnContent()
        

          21
                  .asString();
        

          22
              System.out.println(query);
        

          23
            }
        

          24
          }
        

          1
          package example;
        

          2
          
        

          3
          import org.apache.http.HttpHost;
        

          4
          import org.apache.http.client.fluent.*;
        

          5
          
        

          6
          public class Main {
        

          7
          
        

          8
            public static void main(String[] args) throws Exception {
        

          9
          
        

          10
              String username = "td-customer-USERNAME";
        

          11
              String password = "PASS";
        

          12
              String proxyHost = "unlimited.thordata.net";
        

          13
              int proxyPort = 9999;
        

          14
          
        

          15
              HttpHost entry = new HttpHost(proxyHost, proxyPort);
        

          16
              String query = Executor.newInstance()
        

          17
                  .auth(entry, username, password)
        

          18
                  .execute(Request.Get("https://ipinfo.thordata.com")
        

          19
                  .viaProxy(entry))
        

          20
                  .returnContent()
        

          21
                  .asString();
        

          22
              System.out.println(query);
        

          23
            }
        

          24
          }
        

          1
          package example;
        

          2
          
        

          3
          import org.apache.http.HttpHost;
        

          4
          import org.apache.http.client.fluent.*;
        

          5
          
        

          6
          public class Main {
        

          7
          
        

          8
            public static void main(String[] args) throws Exception {
        

          9
          
        

          10
              String username = "td-customer-USERNAME";
        

          11
              String password = "PASS";
        

          12
              String proxyHost = "user.pr.thordata.net";
        

          13
              int proxyPort = 5555;
        

          14
          
        

          15
              HttpHost entry = new HttpHost(proxyHost, proxyPort);
        

          16
              String query = Executor.newInstance()
        

          17
                  .auth(entry, username, password)
        

          18
                  .execute(Request.Get("https://ipinfo.thordata.com")
        

          19
                  .viaProxy(entry))
        

          20
                  .returnContent()
        

          21
                  .asString();
        

          22
              System.out.println(query);
        

          23
            }
        

          24
          }
        

          1
          import java.io.*;
        

          2
          import java.net.HttpURLConnection;
        

          3
          import java.net.URL;
        

          4
          import java.net.URLEncoder;
        

          5
          import java.nio.charset.StandardCharsets;
        

          6
          import java.util.ArrayList;
        

          7
          import java.util.HashMap;
        

          8
          import java.util.List;
        

          9
          import java.util.Map;
        

          10
          
        

          11
          public class Main {
        

          12
            public static void main(String[] args) {
        

          13
              String targetURL = "https://scraperapi.thordata.com/builder";
        

          14
          
        

          15
              // Create the spider info data structure
        

          16
              List<Map<String, String>> spiderInfo = new ArrayList<>();
        

          17
              
        

          18
              Map<String, String> param1 = new HashMap<>();
        

          19
                param1.put("url", "https://www.youtube.com/@stephcurry/videos");
        

          20
                param1.put("order_by", "");
        

          21
                param1.put("num_of_posts", "");
        

          22
                spiderInfo.add(param1);
        

          23
          
        

          24
              
        

          25
              try {
        

          26
                // Convert spiderInfo to JSON
        

          27
                String spiderInfoJSON = new com.google.gson.Gson().toJson(spiderInfo);
        

          28
                
        

          29
                // Prepare form data
        

          30
                String formData = "spider_name=" + URLEncoder.encode("youtube.com", StandardCharsets.UTF_8) + 
        

          31
                "&spider_id=" + URLEncoder.encode("youtube_video-post_by-url", StandardCharsets.UTF_8) + 
        

          32
                "&spider_parameters=" + URLEncoder.encode(spiderInfoJSON, StandardCharsets.UTF_8) + 
        

          33
                "&spider_errors=" + URLEncoder.encode("true", StandardCharsets.UTF_8) + 
        

          34
                "&file_name=" + URLEncoder.encode("{{VideoID}}", StandardCharsets.UTF_8);
        

          35
          
        

          36
                // Create and configure the connection
        

          37
                HttpURLConnection connection = (HttpURLConnection) new URL(targetURL).openConnection();
        

          38
                connection.setRequestMethod("POST");
        

          39
                connection.setRequestProperty("Authorization", "Bearer Token");
        

          40
                connection.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
        

          41
                connection.setDoOutput(true);
        

          42
          
        

          43
                // Send the request
        

          44
                try (OutputStream os = connection.getOutputStream()) {
        

          45
                  byte[] input = formData.getBytes(StandardCharsets.UTF_8);
        

          46
                  os.write(input, 0, input.length);
        

          47
                }
        

          48
          
        

          49
                // Get the response
        

          50
                int statusCode = connection.getResponseCode();
        

          51
                String responseBody;
        

          52
                try (InputStream is = connection.getInputStream();
        

          53
                  BufferedReader br = new BufferedReader(new InputStreamReader(is, StandardCharsets.UTF_8))) {
        

          54
                  StringBuilder response = new StringBuilder();
        

          55
                  String responseLine;
        

          56
                  while ((responseLine = br.readLine()) != null) {
        

          57
                    response.append(responseLine.trim());
        

          58
                  }
        

          59
                  responseBody = response.toString();
        

          60
                }
        

          61
          
        

          62
                System.out.println("Status Code: " + statusCode);
        

          63
                System.out.println("Response Body: " + responseBody);
        

          64
          
        

          65
              } catch (Exception e) {
        

          66
                System.err.println("Error: " + e.getMessage());
        

          67
                e.printStackTrace();
        

          68
              }
        

          69
            }
        

          70
          }
        

          1
          import java.net.URI;
        

          2
          import java.net.http.HttpClient;
        

          3
          import java.net.http.HttpRequest;
        

          4
          import java.net.http.HttpResponse;
        

          5
          import java.net.URLEncoder;
        

          6
          import java.nio.charset.StandardCharsets;
        

          7
          import java.util.Map;
        

          8
          import java.util.stream.Collectors;
        

          9
          
        

          10
          public class Main {
        

          11
              public static void main(String[] args) throws Exception {
        

          12
                  String formData = buildFormData(
        

          13
                      "url", "https://www.google.com",
        

          14
                      "type", "html",
        

          15
                      "js_render", "True"
        

          16
              );
        

          17
                  
        

          18
                  HttpRequest request = HttpRequest.newBuilder()
        

          19
                          .uri(URI.create("https://webunlocker.thordata.com/request"))
        

          20
                          .header("Authorization", "Bearer Token")
        

          21
                          .header("content-type", "application/x-www-form-urlencoded")
        

          22
                          .POST(HttpRequest.BodyPublishers.ofString(formData))
        

          23
                          .build();
        

          24
                  
        

          25
                  HttpResponse<String> response = HttpClient.newHttpClient()
        

          26
                          .send(request, HttpResponse.BodyHandlers.ofString());
        

          27
                  
        

          28
                  System.out.println(response.body());
        

          29
              }
        

          30
              
        

          31
              
        

          32
              private static String buildFormData(String... keyValuePairs) {
        

          33
                  if (keyValuePairs.length % 2 != 0) {
        

          34
                      throw new IllegalArgumentException("Parameters must be key-value pairs.");
        

          35
                  }
        

          36
                  
        

          37
                  StringBuilder sb = new StringBuilder();
        

          38
                  for (int i = 0; i < keyValuePairs.length; i += 2) {
        

          39
                      if (i > 0) sb.append("&");
        

          40
                      sb.append(keyValuePairs[i])
        

          41
                        .append("=")
        

          42
                        .append(URLEncoder.encode(keyValuePairs[i+1], StandardCharsets.UTF_8));
        

          43
                  }
        

          44
                  return sb.toString();
        

          45
              }
        

          46
          }
        

          1
          import java.io.*;
        

          2
          import java.net.HttpURLConnection;
        

          3
          import java.net.URL;
        

          4
          import java.net.URLEncoder;
        

          5
          
        

          6
          public class ScraperApiExample {
        

          7
          
        

          8
              public static void main(String[] args) {
        

          9
                  try {
        

          10
                      String formData = String.format("engine=%s&q=%s&json=%s",
        

          11
                              URLEncoder.encode("google", "UTF-8"),
        

          12
                              URLEncoder.encode("pizza", "UTF-8"),
        

          13
                              URLEncoder.encode("1", "UTF-8"));
        

          14
                      
        

          15
                      URL url = new URL("https://scraperapi.thordata.com/request");
        

          16
                      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        

          17
                      conn.setRequestMethod("POST");
        

          18
                      conn.setDoOutput(true);
        

          19
                      conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
        

          20
                      conn.setRequestProperty("Authorization", "Bearer Token");
        

          21
                      
        

          22
                      try (DataOutputStream dos = new DataOutputStream(conn.getOutputStream())) {
        

          23
                          dos.writeBytes(formData);
        

          24
                          dos.flush();
        

          25
                      }
        

          26
                      
        

          27
                      int responseCode = conn.getResponseCode();
        

          28
                      StringBuilder response = new StringBuilder();
        

          29
                      
        

          30
                      try (BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()))) {
        

          31
                          String inputLine;
        

          32
                          while ((inputLine = in.readLine()) != null) {
        

          33
                              response.append(inputLine);
        

          34
                          }
        

          35
                      }
        

          36
                      
        

          37
                      System.out.println("Status: " + responseCode);
        

          38
                      System.out.println("Body: " + response.toString());
        

          39
                      
        

          40
                      conn.disconnect();
        

          41
                      
        

          42
                  } catch (Exception e) {
        

          43
                      e.printStackTrace();
        

          44
                  }
        

          45
              }
        

          46
          }
        

          1
          using System;
        

          2
          using System.Net;
        

          3
          
        

          4
          class Example
        

          5
          {
        

          6
            static void Main()
        

          7
            {  
        

          8
              var username = "td-customer-USERNAME";
        

          9
              var password = "PASS";
        

          10
              var proxy = "user.pr.thordata.net:9999";
        

          11
          
        

          12
              var client = new WebClient();
        

          13
              client.Proxy = new WebProxy(proxy);
        

          14
              client.Proxy.Credentials = new NetworkCredential(username, password);
        

          15
          
        

          16
              Console.WriteLine(client.DownloadString("https://ipinfo.thordata.com"));
        

          17
            }
        

          18
          }
        

          1
          using System;
        

          2
          using System.Net;
        

          3
          
        

          4
          class Example
        

          5
          {
        

          6
            static void Main()
        

          7
            {  
        

          8
              var username = "td-customer-USERNAME";
        

          9
              var password = "PASS";
        

          10
              var proxy = "IP:PORT";
        

          11
          
        

          12
              var client = new WebClient();
        

          13
              client.Proxy = new WebProxy(proxy);
        

          14
              client.Proxy.Credentials = new NetworkCredential(username, password);
        

          15
          
        

          16
              Console.WriteLine(client.DownloadString("https://ipinfo.thordata.com"));
        

          17
            }
        

          18
          }
        

          1
          using System;
        

          2
          using System.Net;
        

          3
          
        

          4
          class Example
        

          5
          {
        

          6
            static void Main()
        

          7
            {  
        

          8
              var username = "td-customer-USERNAME";
        

          9
              var password = "PASS";
        

          10
              var proxy = "IP:PORT";
        

          11
          
        

          12
              var client = new WebClient();
        

          13
              client.Proxy = new WebProxy(proxy);
        

          14
              client.Proxy.Credentials = new NetworkCredential(username, password);
        

          15
          
        

          16
              Console.WriteLine(client.DownloadString("https://ipinfo.thordata.com"));
        

          17
            }
        

          18
          }
        

          1
          using System;
        

          2
          using System.Net;
        

          3
          
        

          4
          class Example
        

          5
          {
        

          6
            static void Main()
        

          7
            {  
        

          8
              var username = "td-customer-USERNAME";
        

          9
              var password = "PASS";
        

          10
              var proxy = "unlimited.thordata.net:9999";
        

          11
          
        

          12
              var client = new WebClient();
        

          13
              client.Proxy = new WebProxy(proxy);
        

          14
              client.Proxy.Credentials = new NetworkCredential(username, password);
        

          15
          
        

          16
              Console.WriteLine(client.DownloadString("https://ipinfo.thordata.com"));
        

          17
            }
        

          18
          }
        

          1
          using System;
        

          2
          using System.Net;
        

          3
          
        

          4
          class Example
        

          5
          {
        

          6
            static void Main()
        

          7
            {  
        

          8
              var username = "td-customer-USERNAME";
        

          9
              var password = "PASS";
        

          10
              var proxy = "user.pr.thordata.net:5555";
        

          11
          
        

          12
              var client = new WebClient();
        

          13
              client.Proxy = new WebProxy(proxy);
        

          14
              client.Proxy.Credentials = new NetworkCredential(username, password);
        

          15
          
        

          16
              Console.WriteLine(client.DownloadString("https://ipinfo.thordata.com"));
        

          17
            }
        

          18
          }
        

          1
          using System;
        

          2
          using System.Collections.Generic;
        

          3
          using System.Net.Http;
        

          4
          using System.Text;
        

          5
          using System.Threading.Tasks;
        

          6
          using System.Web;
        

          7
          
        

          8
          class Program
        

          9
          {
        

          10
            static async Task Main(string[] args)
        

          11
            {
        

          12
              var client = new HttpClient();
        

          13
              var targetUrl = "https://scraperapi.thordata.com/builder";
        

          14
          
        

          15
              var spiderInfo = new List<Dictionary<string, string>>
        

          16
              {
        

          17
                new Dictionary<string, string>
        

          18
                {
        

          19
                  {"url", "https://www.youtube.com/@stephcurry/videos"},
        

          20
                  {"order_by", ""},
        

          21
                  {"num_of_posts", ""}
        

          22
                }
        

          23
              };
        

          24
              
        

          25
              var spiderInfoJson = Newtonsoft.Json.JsonConvert.SerializeObject(spiderInfo);
        

          26
              
        

          27
              var formData = new Dictionary<string, string>
        

          28
              {
        

          29
                { "spider_name", "youtube.com" },
        

          30
                { "spider_id", "youtube_video-post_by-url" },
        

          31
                { "spider_parameters", spiderInfoJson },
        

          32
                { "spider_errors", "true" },
        

          33
                { "file_name", "{{VideoID}}"}
        

          34
              };
        

          35
          
        

          36
              var request = new HttpRequestMessage(HttpMethod.Post, targetUrl)
        

          37
              {
        

          38
                Content = new FormUrlEncodedContent(formData)
        

          39
              };
        

          40
          
        

          41
              request.Headers.Add("Authorization", "Bearer Token");
        

          42
          
        

          43
              try
        

          44
              {
        

          45
                var response = await client.SendAsync(request);
        

          46
                var responseBody = await response.Content.ReadAsStringAsync();
        

          47
          
        

          48
                Console.WriteLine($"Status Code: {(int)response.StatusCode}");
        

          49
                Console.WriteLine($"Response Body: {responseBody}");
        

          50
              }
        

          51
              catch (HttpRequestException e)
        

          52
              {
        

          53
                Console.WriteLine($"Error sending request: {e.Message}");
        

          54
              }
        

          55
            }
        

          56
          }
        

          1
          using System; 
        

          2
          using System.Net.Http; 
        

          3
          using System.Net.Http.Headers; 
        

          4
          using System.Collections.Generic; 
        

          5
          using System.Threading.Tasks; 
        

          6
          using System.Web; 
        

          7
          class Program 
        

          8
          { 
        

          9
              static async Task Main(string[] args) 
        

          10
              {  
        

          11
                  var client = new HttpClient(); 
        

          12
                  var request = new HttpRequestMessage 
        

          13
                  { 
        

          14
                      Method = HttpMethod.Post, 
        

          15
                      RequestUri = new Uri(" https://webunlocker.thordata.com/request"), 
        

          16
                      Headers = 
        

          17
                      { 
        

          18
                          { "Authorization", "Bearer Token" },
        

          19
                      }, 
        

          20
                      Content = new FormUrlEncodedContent(new Dictionary<string, string> 
        

          21
                      {
        

          22
                      {"url", "https://www.google.com"},
        

          23
                      {"type", "html"},
        

          24
                      {"js_render", "True"}
        

          25
                      })
        

          26
                  }; 
        

          27
                  
        

          28
                  request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded"); 
        

          29
                  using (var response = await client.SendAsync(request)) 
        

          30
                  { 
        

          31
                      response.EnsureSuccessStatusCode(); 
        

          32
                      var body = await response.Content.ReadAsStringAsync(); 
        

          33
                      Console.WriteLine(body); 
        

          34
                  } 
        

          35
              } 
        

          36
          }
        

          1
          using System;
        

          2
          using System.Collections.Generic;
        

          3
          using System.Net.Http;
        

          4
          using System.Threading.Tasks;
        

          5
          class Program
        

          6
          {
        

          7
              static async Task Main(string[] args)
        

          8
              {
        

          9
                  var client = new HttpClient();
        

          10
                  var request = new HttpRequestMessage(
        

          11
                      HttpMethod.Post, 
        

          12
                      "https://scraperapi.thordata.com/request"
        

          13
                  );
        

          14
                  request.Headers.Add("Authorization", "Bearer Token");
        

          15
                  
        

          16
                  var formData = new Dictionary<string, string>
        

          17
                  {
        

          18
                  {"engine", "google"},
        

          19
                  {"q", "pizza"},
        

          20
                  {"json", "1"}
        

          21
          };
        

          22
                  
        

          23
                  var content = new FormUrlEncodedContent(formData);
        

          24
                  request.Content = content;
        

          25
                  
        

          26
                  var response = await client.SendAsync(request);
        

          27
                  response.EnsureSuccessStatusCode();
        

          28
                  Console.WriteLine(await response.Content.ReadAsStringAsync());
        

          29
              }
        

          30
          }