Gói Đầu Tiên Của Bạn Miễn Phí!

Trả lại 100% giá trị mua proxy dân cư lần đầu tiên vào số dư ví, tối đa 900 đô la.

Data for AI

Việt Nam

Đăng nhập Dùng thử miễn phí

Giải pháp

AI Training

Boost AI & LLM Data Scraping với dịch vụ Proxy không giới hạn

Name: Proxy tốt nhất cho việc thu thập dữ liệu đào tạo AI và LLM
Brand: Thordata
Rating: 4.8 (3678 reviews)

Thanh toán theo băng thông, không IP/lưu lượng giới hạn. Điều chỉnh sự trùng hợp và băng thông linh hoạt cho các hoạt động cắt xén web dễ dàng với quy mô.

60 triệu IPs cư trú, bao gồm hơn 190 khu vực trên toàn thế giới

Linh hoạt song hành và quản lý băng thông để dễ dàng mở rộng

20MB/s cho mỗi IP, hoàn hảo cho việc tải video, âm thanh và hình ảnh theo quy mô

Cho đến hàng nghìn lần phản ứng

Dùng thử miễn phí

Dùng thử miễn phí

Cách Thordata Tăng Cường Đào Tạo LLM và ML ?

Dù bạn đang xây dựng các mô hình nền tảng, nâng cao khả năng đa phương tiện hay củng cố các ứng dụng theo chiều dọc, Thordata cung cấp các bộ dữ liệu lớn, chất lượng cao và có cấu trúc để tăng hiệu suất mô hình.

Mạng Proxy Ổn Định Cao

Thordata cung cấp mạng proxy toàn cầu ẩn danh và ổn định cao để giúp người dùng truy cập liền mạch vào các trang web mục tiêu.

Tự động xoay vòng các IP thất bại để đảm bảo quá trình thu thập dữ liệu không bị gián đoạn

IP proxy ổn định cao được lấy từ các nguồn mạng đáng tin cậy

Máy Chủ Proxy Tùy Chỉnh

Thordata cung cấp băng thông không giới hạn và cấu hình máy chủ tùy chỉnh để hỗ trợ triển khai nhanh chóng các hệ thống thu thập dữ liệu chuyên dụng.

Hỗ trợ thu thập dữ liệu có cấu trúc/phi cấu trúc, bao gồm nội dung web, đánh giá, thông tin sản phẩm, mạng xã hội và tin tức

Tùy chỉnh băng thông và cài đặt CPU dựa trên nhu cầu thực tế để tránh lãng phí tài nguyên

Tài Nguyên IP Khổng Lồ

Dịch vụ proxy không giới hạn của Thordata đi kèm với một kho IP hàng đầu toàn cầu, cho phép các doanh nghiệp thực hiện thu thập dữ liệu mạnh mẽ trên nhiều khu vực.

Bao phủ hơn 70 quốc gia và khu vực, đáp ứng nhu cầu thu thập dữ liệu quy mô toàn cầu

Lý tưởng cho triển khai quy mô lớn với tỷ lệ chi phí-hiệu suất vượt xa các mô hình tính phí dựa trên lưu lượng truyền thống

Làm Sạch và Cấu Trúc Dữ Liệu

Thordata cung cấp các mô-đun cơ sở dữ liệu đã được xử lý trước, lấp đầy khoảng cách quan trọng giữa việc thu thập dữ liệu và đầu vào mô hình.

Tự động xác định cấu trúc trang và loại nội dung, xuất dữ liệu có cấu trúc ở định dạng JSON/CSV

Loại bỏ nội dung không liên quan, quảng cáo, văn bản bị lỗi và dữ liệu trùng lặp

Tương thích với các hệ thống gán nhãn của bên thứ ba để giúp xây dựng các bộ dữ liệu đã được gán nhãn

Lợi ích chính của việc huấn luyện LLM với proxy

Độ trễ thấp

Giảm thiểu độ trễ trong việc thu thập dữ liệu để tăng tốc quá trình lặp lại của mô hình.

Thời gian hoạt động ổn định

Thời gian hoạt động 99,7% đảm bảo quá trình huấn luyện và kiểm tra không bị gián đoạn.

Huấn luyện tùy chỉnh

Sử dụng dịch vụ proxy không giới hạn tốt nhất dành riêng cho huấn luyện LLM, bạn có thể huấn luyện thoải mái.

Ứng dụng AI hưởng lợi từ proxy không giới hạn

Dịch vụ Proxy Không Giới Hạn của chúng tôi lý tưởng cho các nhiệm vụ liên quan đến AI:

Thu thập Dữ liệu Huấn luyện

Thu thập hiệu quả các bộ dữ liệu lớn để huấn luyện trong các lĩnh vực như xử lý ngôn ngữ tự nhiên (NLP), thị giác máy tính, v.v.

Nghiên cứu và Phân tích Thị trường

Thu thập giá cả, thông tin sản phẩm từ nhiều nguồn khác nhau để huấn luyện hệ thống AI dự báo và phân tích thị trường.

Giám sát Giá cả

Liên tục thu thập dữ liệu giá từ các thị trường thương mại điện tử để AI của bạn có thể tạo ra dự báo giá chính xác và cung cấp thông tin chi tiết.

Tại sao chọn Thordata?

Phủ sóng dữ liệu toàn cầu

Hỗ trợ tài nguyên tại hơn 70 quốc gia và khu vực

Thu thập dữ liệu hiệu quả

Hàng chục nghìn yêu cầu đồng thời để thu thập nội dung nhanh chóng

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

Cấu hình CPU và băng thông linh hoạt theo nhu cầu

Đảm bảo chất lượng dữ liệu

Xuất dữ liệu có cấu trúc ở định dạng JSON/CSV

Đảm bảo tuân thủ

Tuân thủ nghiêm ngặt các quy định về quyền riêng tư dữ liệu toàn cầu

Hỗ trợ khách hàng nhanh chóng

Hỗ trợ kỹ thuật 24/7, sẵn sàng giải đáp mọi thắc mắc của bạn

Số ngày

Máy chủ

Băng thông (Mbps)

Proxy băng thông cao

Máy chủ

Băng thông

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

Quản lý danh sách trắng IP

Trích xuất API hiệu quả

Hơn 47 triệu IP

Kết nối đồng thời không giới hạn

Giám sát dữ liệu thời gian thực

Hoàn hảo cho thu thập dữ liệu quy mô lớn

Trích xuất IP không giới hạn

Phủ sóng 70+ quốc gia/vùng

Máy chủ riêng chuyên dụng

Cấu hình tài khoản phụ linh hoạt

Hỗ trợ tùy chỉnh băng thông & máy chủ

Chúng tôi chấp nhận các phương thức thanh toán sau:

Gói giá dịch vụ Proxy không giới hạn

Customizable IP by country

Phân bổ băng thông chuyên dụng

Lịch trình linh hoạt

Cấu hình máy chủ tùy chỉnh



          
          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#

Tài Liệu Tích Hợp API Thân Thiện Với Nhà Phát Triển

Thordata cung cấp tài liệu API rõ ràng và có cấu trúc tốt để giúp các nhà phát triển tích hợp hiệu quả chức năng proxy và thu thập dữ liệu. Dù bạn mới bắt đầu tìm hiểu về web scraping hay đang xây dựng hệ thống dữ liệu AI phức tạp, tài liệu của chúng tôi sẽ hướng dẫn bạn chi tiết từng bước.

Xem tích hợp

Cần Giải Pháp Tùy Chỉnh?

Tối ưu hóa lưu lượng truy cập theo mô hình cá nhân hóa:Chúng tôi thiết kế giải pháp proxy dựa trên mô hình lưu lượng và yêu cầu sử dụng cụ thể của bạn.

Tùy chọn Proxy theo khu vực địa lý:Nhận IP từ các quốc gia hoặc khu vực cụ thể phù hợp với nhu cầu doanh nghiệp của bạn.

Gói tiết kiệm chi phí:Chúng tôi sẽ đề xuất giải pháp tối ưu nhất dựa trên mục tiêu và ngân sách của bạn.

Liên hệ với quản lý tài khoản riêng của bạn ngay hôm nay để tạo giải pháp proxy dân cư tùy chỉnh cho doanh nghiệp của bạn!

Tên

Địa chỉ Email

Thông điệp của bạn

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

Tại sao các Mô hình Ngôn ngữ Lớn (LLMs) cần proxy để đào tạo?

Khi đào tạo LLMs hoặc các mô hình học máy khác, dữ liệu chất lượng cao và đa dạng là rất quan trọng. Tuy nhiên, việc thu thập dữ liệu như vậy thường liên quan đến việc thu thập nội dung từ nhiều trang web và khu vực toàn cầu, đối mặt với các thách thức như giới hạn tốc độ, hạn chế địa lý, chặn IP và vấn đề về tính toàn vẹn dữ liệu.

Sử dụng dịch vụ proxy chất lượng cao, đặc biệt là giải pháp proxy không giới hạn, giúp vượt qua những trở ngại này bằng cách cho phép truy cập ổn định, hiệu quả và tuân thủ dữ liệu web toàn cầu, tạo nền tảng dữ liệu vững chắc cho việc đào tạo LLM.

Những công cụ AI nào tương thích với dịch vụ proxy của Thordata?

Dịch vụ proxy của Thordata tương thích cao với nhiều công cụ liên quan đến AI và hệ thống thu thập dữ liệu, bao gồm nhưng không giới hạn:

Các khung đào tạo mô hình mã nguồn mở như Hugging Face, TensorFlow và PyTorch

Hệ thống Tăng cường Truy xuất (RAG) như LangChain và LlamaIndex

Công cụ và khung web scraping như Scrapy, Selenium, BeautifulSoup và Playwright

Dù bạn đang thu thập các trang web tĩnh, nội dung động hay thực hiện truy cập đồng thời quy mô lớn, Thordata cung cấp hỗ trợ proxy linh hoạt và mạnh mẽ.

Làm thế nào để bắt đầu với Proxy Không Giới Hạn của Thordata?

1.Tạo tài khoản: Truy cập https://www.thordata.com và đăng ký bằng email của bạn.

2.Chọn gói hoặc đăng ký dùng thử miễn phí: Chọn gói proxy không giới hạn phù hợp nhất với nhu cầu của bạn hoặc đăng ký dùng thử miễn phí để trải nghiệm dịch vụ của chúng tôi.

3.Tích hợp với công cụ hoặc mã của bạn: Truy cập chi tiết API hoặc thông tin xác thực proxy và tích hợp chúng vào script scraping hiện có hoặc hệ thống AI của bạn chỉ trong vài phút.

Nhiều câu hỏi

Chat with usLiveChat