Best High-Bandwidth Proxies Service

Name: Best High-Bandwidth Proxies Service - Free Trial
Brand: Thordata
Rating: 4.8 (3678 reviews)
Your First Plan is on Us!
Get 100% of your first residential proxy purchase back as wallet balance, up to $900.
Start now

Data for AI
What is High-Bandwidth Proxy?

High-Bandwidth Proxies are designed for video scraping and large-scale downloads, handling high-concurrency, low-latency transfers while preventing interruptions and delays.
Automatic proxy rotation
Millions of IPs from diverse subnets
Offers Customized Solutions
High bandwidth, high concurrency, and high-volume transfer support
Competitive pricing on demand

Thordata optimized IP pool management is tailored to your needs, delivering exceptional value at a lower cost.
Number of days
Server
Bandwidth (Mbps)
High-Bandwidth Proxies
Server
Bandwidth
Get more customized services.

Dedicated bandwidth allocation
Customizable IP by country
Custom server configuration
Dedicated account manager
Intelligent load balancing
24/7 priority support
We accept these payment methods:
Included in the price with no additional fees:

Unlimited concurrent connections
Fully dedicated, no sharing
Customizable bandwidth options
Rotating & sticky sessions
User & whitelist authentication
Easy-to-integrate open API
High performance for effortless scaling

Designed for scale, our infrastructure seamlessly handles massive volumes of video data from the most popular video platforms while maintaining consistent performance.
Elastic proxy infrastructure
Custom 100Gbps+ Dedicated Bandwidth
Private Deployment with Exclusive Resource Access
Reliably high success rate

With smart IP management, large subnet diversity, and persistent connections, we help you avoid blocks, timeouts, and failed transfers.
Over 47 million IPs available
Automatic error detection and proxy rotation
Pre-built IP cooldown mechanism
Instant Proxy Integration

Start scraping video or audio data in minutes. Receive a dedicated HTTP proxy exit node (a single node or multiple), replace your current one with it (if you are already using proxies), and that's it!
Dedicated setups tailored to your needs
Fully compatible with yt-dlp
Private and self-managed storage
See documentation

          
          import requests
        
          username = "USERNAME"
        
          password = "PASSWORD"
        
          proxy = "user.pr.thordata.net: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.net: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.net: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.net: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.net:9999 -U "td-customer-USERNAME:PASSWORD" https://ipinfo.thordata.com
        
          curl -x user.pr.thordata.net: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.net: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.net: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.net: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.net: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.net: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.net: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.net: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.net: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.net: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.net";
        
              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.net";
        
              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.net";
        
              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.net: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.net: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.net: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;
        
          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());
        
              }
        
          }
        
Python
cURL
Node.js
PHP
GO
Java
C#
High-Bandwidth Proxies: get the advantage

High download capacity

Our infrastructure supports large-scale video scraping with 100+ Gbps bandwidth for fast, reliable high-volume downloads.
Persistent connections

We maintain stable connections during the full duration of the fetched result - perfect for high-volume video data downloads.
Automatic proxy rotation

Our system rotates IPs on your behalf to mimic real user behavior and reduce the risk of blocks or CAPTCHAs.
IP cooldown mechanism

We automatically retire overused IPs and reintroduce them after a cooldown period to maintain high success rates.
Built-in traffic load balancing

Our infrastructure distributes proxies amongst a high volume of servers to keep performance consistent and scalable.
Open-source library compatibility

Our proxy interface is compatible with yt-dlp and other most popular open source libraries.
Frequently asked questions

What are High-Bandwidth Proxies for video download?

High-Bandwidth Proxies are optimized servers that let you download and scrape video or audio data quickly and reliably. They support large data transfers without slowdowns or interruptions.
Is it legal to use these proxies with YouTube?

Using proxies is legal, but scraping or downloading YouTube content may violate YouTube's Terms of Service. Always consult legal counsel and ensure your use complies with relevant laws and regulations.
Can I perform bulk video downloads?

Yes, our proxies are designed for bulk video downloads and large-scale scraping. You can handle thousands or even millions of requests efficiently.
What download speeds can I expect?

Each download speed is individually optimized, with the actual experience depending on server location and the user's local environment. In terms of overall concurrent capacity, our high-bandwidth proxies support extremely high volumes of simultaneous downloads.
How do High-Bandwidth Proxies differ from standard proxies?

High-Bandwidth Proxies offer faster speeds and greater data capacity than regular proxies. They're ideal for large-scale tasks like downloading video or audio data for AI model training from the most popular video platforms.
More FAQs
Power AI training with large-scale video & audio data.

Chat with usLiveChat
High-Bandwidth Proxy for Video Data Download

What is High-Bandwidth Proxy?

Competitive pricing on demand

Get more customized services.

Included in the price with no additional fees:

High performance for effortless scaling

Reliably high success rate

Instant Proxy Integration

High-Bandwidth Proxies: get the advantage

High download capacity

Persistent connections

Automatic proxy rotation

IP cooldown mechanism

Built-in traffic load balancing

Open-source library compatibility

Frequently asked questions

What are High-Bandwidth Proxies for video download?

Is it legal to use these proxies with YouTube?

Can I perform bulk video downloads?

What download speeds can I expect?

How do High-Bandwidth Proxies differ from standard proxies?

Power AI training with large-scale video & audio data.
