Proxys de centre de données
Keep your collector and route eligible public-web requests through a datacenter-origin identity. This category is designed for economical, predictable high-throughput work where representative targets accept datacenter traffic.
Buyer fit
Datacenter-origin identity can make economic and operational sense for predictable, high-throughput collection, but only when the eligible public targets in scope accept that traffic.
Strong evaluation candidate
Keep the HTTP client, browser, or crawler while evaluating a datacenter-origin route for a stable, repeatable workload.
Representative targets accept datacenter traffic.
Demand is understood well enough to scope capacity.
Your team owns retries, parsing, storage, and quality.
Validate before scale
Test representative eligible public pages, success criteria, response handling, and conservative request behavior before committing to an allocation.
Review source terms and intended use.
Measure the target responses your collector receives.
Match the current offer to the workload.
Choose another path when needed
Evaluate Residential or ISP Proxies when the identity category matters, or a web access API when your team does not want to own the outbound fetch client.
Provisioned controls
Use account-specific endpoint, authentication, protocol, geography, allocation, and pricing details. Do not infer them from a generic example.
Share the baseline, peak windows, and continuity requirements so the proposed capacity and allocation model match your workload.
Use only the account-specific endpoint and authentication method supplied during provisioning. Keep every connection value server-side.
Use the supported protocol for your account, then verify that the provisioned configuration maps cleanly to your proxy-aware client.
Treat datacenter-origin identity as the known category. Use the geographic options and selection behavior available for your provisioned route.
Capacity and continuity
Your collector defines concurrency, timeout, and retry behavior. Align the provisioned allocation and any rotation, persistence, or session behavior with those requirements.
Collector brief
Provisioned route
Baseline test
Run a representative request set against eligible public targets.
Peak-window test
Exercise the demand shape without bypassing collector limits.
Failure-path test
Verify timeout, retry, backoff, and stop behavior.
Developer integration
Store the account-specific connection details in protected server-side environment variables. These generic patterns deliberately do not publish or imply a WebScrapingAPI endpoint.
01 Provision before connecting
Evaluate representative targets and provision endpoint, authentication, protocol, geography, allocation, and pricing before deploying client configuration.
test -n "$WSA_DATACENTER_PROXY_URL" || exit 1
curl --fail --show-error \
--proxy "$WSA_DATACENTER_PROXY_URL" \
"https://example.com/public-page"import { ProxyAgent, fetch } from "undici";
const proxyUrl = process.env.WSA_DATACENTER_PROXY_URL;
if (!proxyUrl) throw new Error("Missing proxy configuration");
const response = await fetch("https://example.com/public-page", {
dispatcher: new ProxyAgent(proxyUrl),
});
if (!response.ok) throw new Error("Target response was not successful");
console.log(await response.text());import os
import requests
proxy_url = os.environ["WSA_DATACENTER_PROXY_URL"]
response = requests.get(
"https://example.com/public-page",
proxies={"http": proxy_url, "https": proxy_url},
timeout=30,
)
response.raise_for_status()
print(response.text)<?php
$proxyUrl = getenv("WSA_DATACENTER_PROXY_URL");
if (!$proxyUrl) throw new RuntimeException("Missing proxy configuration");
$client = curl_init("https://example.com/public-page");
curl_setopt_array($client, [
CURLOPT_PROXY => $proxyUrl,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_TIMEOUT => 30,
]);
$body = curl_exec($client);
if ($body === false) throw new RuntimeException(curl_error($client));
curl_close($client);
echo $body;package main
import (
"io"
"log"
"net/http"
"net/url"
"os"
"time"
)
func main() {
proxyURL, err := url.Parse(os.Getenv("WSA_DATACENTER_PROXY_URL"))
if err != nil { log.Fatal(err) }
client := &http.Client{
Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
Timeout: 30 * time.Second,
}
response, err := client.Get("https://example.com/public-page")
if err != nil { log.Fatal(err) }
defer response.Body.Close()
body, err := io.ReadAll(response.Body)
if err != nil { log.Fatal(err) }
log.Print(string(body))
}import java.net.*;
import java.net.http.*;
public class DatacenterProxyExample {
public static void main(String[] args) throws Exception {
var host = System.getenv("WSA_DATACENTER_PROXY_HOST");
var port = System.getenv("WSA_DATACENTER_PROXY_PORT");
var username = System.getenv("WSA_DATACENTER_PROXY_USERNAME");
var password = System.getenv("WSA_DATACENTER_PROXY_PASSWORD");
if (host == null || port == null || username == null || password == null) {
throw new IllegalStateException("Missing provisioned Datacenter Proxy values");
}
var address = new InetSocketAddress(host, Integer.parseInt(port));
var client = HttpClient.newBuilder()
.proxy(ProxySelector.of(address))
.authenticator(new Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(
username,
password.toCharArray()
);
}
})
.build();
var request = HttpRequest.newBuilder()
.uri(URI.create("https://example.com/public-page"))
.GET()
.build();
System.out.println(client.send(
request, HttpResponse.BodyHandlers.ofString()
).body());
}
}using System.Net;
var proxyHost = Environment.GetEnvironmentVariable("WSA_DATACENTER_PROXY_HOST")
?? throw new InvalidOperationException("Missing WSA_DATACENTER_PROXY_HOST");
var proxyPort = Environment.GetEnvironmentVariable("WSA_DATACENTER_PROXY_PORT")
?? throw new InvalidOperationException("Missing WSA_DATACENTER_PROXY_PORT");
var proxyUser = Environment.GetEnvironmentVariable("WSA_DATACENTER_PROXY_USERNAME")
?? throw new InvalidOperationException("Missing WSA_DATACENTER_PROXY_USERNAME");
var proxyPassword = Environment.GetEnvironmentVariable("WSA_DATACENTER_PROXY_PASSWORD")
?? throw new InvalidOperationException("Missing WSA_DATACENTER_PROXY_PASSWORD");
var proxyUri = new Uri("http://" + proxyHost + ":" + proxyPort);
var proxy = new WebProxy(proxyUri) {
Credentials = new NetworkCredential(proxyUser, proxyPassword)
};
using var client = new HttpClient(new HttpClientHandler { Proxy = proxy }) {
Timeout = TimeSpan.FromSeconds(30)
};
Console.WriteLine(await client.GetStringAsync(
"https://example.com/public-page"
));import { chromium } from "playwright";
const server = process.env.WSA_DATACENTER_PROXY_SERVER;
const username = process.env.WSA_DATACENTER_PROXY_USERNAME;
const password = process.env.WSA_DATACENTER_PROXY_PASSWORD;
if (!server || !username || !password) {
throw new Error("Missing provisioned Datacenter Proxy values");
}
const browser = await chromium.launch({
proxy: {
server,
username,
password,
},
});
const page = await browser.newPage();
await page.goto("https://example.com/public-page");
console.log(await page.title());
await browser.close();Do not expose endpoints or credentials in browser-delivered code, public repositories, screenshots, analytics, or client-side logs.
Operating ownership
Clear ownership keeps capacity planning separate from target selection, request policy, response handling, and downstream data decisions.
WebScrapingAPI
WebScrapingAPI operates the provisioned datacenter-origin route and account-specific connection controls.
Votre équipe
Your team owns target selection, request policy, client logic, concurrency, timeouts, retries, parsing, storage, and downstream quality.
Qualify
Choose eligible public targets and validate datacenter acceptance.
Provision
Set the connection, allocation, geography, and pricing scope.
Collect
Your client sends requests through the provisioned route.
Opérer
Your team handles retries, parsing, storage, and quality controls.
Use the service only for eligible public webpages. Review source terms, applicable requirements, and the Accord de service, then apply conservative request and retention policies.
Use cases
These patterns are fit examples, not acceptance claims. Your team remains responsible for target eligibility, collection design, parsing, storage, and data use.
Proxy choice
The route category is the first decision. Account-specific endpoint, protocol, geography, allocation, session behavior, availability, and pricing come from the provisioned offer.
Decision | Centre de données | Résidence | Département d'accès |
|---|---|---|---|
Network identity | Datacenter-origin IPs | Real residential IPs | ISP-associated IPs |
Buyer lens | Economical, predictable high-throughput fit for eligible targets that accept datacenter traffic | Evaluate when the workflow needs residential identity | Evaluate when the workflow needs ISP-associated identity |
Target acceptance | Validate representative targets before scale | Validate representative targets before scale | Validate representative targets before scale |
Controls | Provisioned for the offer | Review the dedicated product details | Provisioned for the offer |
Customer ownership | Collector, retries, parsing, and storage | Collector, retries, parsing, and storage | Collector, retries, parsing, and storage |
Swipe horizontally to compare all three proxy categories.
Choose Datacenter Proxies when
your team operates the full collection stack, predictable capacity matters, and representative eligible public targets accept a datacenter-origin route.
Pricing and provisioning
Pricing depends on billing basis, capacity, allocation, availability, geography, and workload shape. No rate or self-serve availability is implied on this page.
Fit check
Share representative eligible public targets, baseline demand, peak windows, continuity needs, and expected response handling.
Provisioning scope
The proposed offer should make the technical and pricing boundary explicit.
FAQ
Use these answers to qualify the category, then provision the connection and pricing details for your workload.
Datacenter Proxies route requests from your proxy-aware client through datacenter-origin IP addresses. They can suit economical, predictable high-throughput collection from eligible public targets that accept datacenter traffic, while your team keeps control of the collector and response workflow.
Use Datacenter Proxies when your team already operates the collector, retries, parsing, and storage, and representative eligible public targets accept datacenter-origin traffic.
No. Datacenter-origin traffic is not accepted by every target. Evaluate representative eligible public targets, respect source terms and request policies, and choose another access path when the category is not a fit.
Use the account-specific endpoint, authentication method, and supported protocol WebScrapingAPI provides during provisioning, and keep every connection value server-side.
Available geography and selection controls depend on the provisioned allocation. Do not design production routing around a location until it is part of your account configuration.
The allocation model and any rotation, persistence, or session behavior depend on the provisioned route. Align the route behavior with your collector's concurrency and continuity requirements.
WebScrapingAPI operates the provisioned proxy route and agreed connection controls. Your team owns target selection, request policy, collector logic, timeouts, retries, parsing, storage, and downstream data quality.
Pricing depends on workload shape, target set, capacity, geography, and allocation needs. Share a representative workload so WebScrapingAPI can scope the right route.
Test representative eligible public targets, validate target acceptance of datacenter traffic, confirm endpoint, protocol, geography, allocation, and pricing, then set conservative timeout, concurrency, retry, retention, and quality rules.
Bring a representative workload
Share the eligible public target set, demand shape, and operating requirements so the route category and current offer can be evaluated.