Proxies residenciais
Keep your HTTP client, browser, or crawler. Send eligible public-web requests through one residential proxy endpoint, with rotating requests by default and short sticky sessions when continuity matters.
Buyer fit
Residential Proxies provide the network path. They do not replace your request client, browser automation, crawler logic, retries, parser, or storage.
Choose Residential Proxies
Keep control of the HTTP client, browser, or crawler while WSA applies the documented residential route and session behavior.
Your client accepts an HTTP, HTTPS, or SOCKS5 proxy.
You want rotating residential IPs or short sticky sessions.
You need documented country selection at the proxy endpoint.
Confirm during evaluation
Confirm that each source and intended use is eligible, then define conservative request, retry, retention, and access rules for your workflow.
Review current country and account availability.
Test representative targets and response handling.
Read the Acordo de serviço.
Consider another path
A request/response API is the clearer fit when your team does not want to own the outbound HTTP client or browser connection.
Connection controls
Start with one backconnect host, then select authentication, country, session behavior, and an output format accepted by your client.
Use país=random for any available documented country, or select one of US, GB, DE, FR, CA, AU, and NL.
Connect with username and password credentials, or use a whitelisted IP and its documented country host.
Generate Host:port, HTTP, HTTPS, or SOCKS5 output according to what your HTTP client, browser, or crawler accepts.
Keep credentials server-side. Do not place proxy usernames, passwords, or generated endpoints in browser code, public repositories, logs, or screenshots.
Rotation and continuity
Residential access is rotating by default. Omit the session and rotation options when requests do not need to keep the same residential IP.
For independent requests, omit session controls and let the endpoint select another residential IP.
Short handoffs and compact multi-step flows.
A balanced window for a reused session ID.
The maximum documented sticky window is 10 minutes.
Developer integration
Generate one proxy endpoint, store it as a server-side secret, and use it in a proxy-aware HTTP client, browser, or crawler. Your application keeps control of requests, retries, parsing, and storage.
01 Build the endpoint first
Select the account-specific options your client needs, then copy the generated endpoint into a protected environment variable.
import os
import requests
proxy_url = os.environ["WSA_RESIDENTIAL_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)export WSA_RESIDENTIAL_PROXY_URL="<GENERATED_PROXY_URL>"
curl --proxy "$WSA_RESIDENTIAL_PROXY_URL" \
--request GET "https://example.com/public-page"import { ProxyAgent, fetch } from "undici";
const proxyUrl = process.env.WSA_RESIDENTIAL_PROXY_URL;
if (!proxyUrl) throw new Error("Missing WSA_RESIDENTIAL_PROXY_URL");
const response = await fetch("https://example.com/public-page", {
dispatcher: new ProxyAgent(proxyUrl),
});
if (!response.ok) throw new Error("Target returned " + response.status);
console.log(await response.text());<?php
$proxyUrl = getenv("WSA_RESIDENTIAL_PROXY_URL");
$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_RESIDENTIAL_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.*;
import java.time.Duration;
public class ResidentialProxyExample {
public static void main(String[] args) throws Exception {
var address = new InetSocketAddress(
System.getenv("WSA_PROXY_HOST"),
Integer.parseInt(System.getenv("WSA_PROXY_PORT"))
);
var client = HttpClient.newBuilder()
.proxy(ProxySelector.of(address))
.authenticator(new Authenticator() {
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(
System.getenv("WSA_PROXY_USERNAME"),
System.getenv("WSA_PROXY_PASSWORD").toCharArray()
);
}
})
.connectTimeout(Duration.ofSeconds(30))
.build();
var request = HttpRequest.newBuilder()
.uri(URI.create("https://example.com/public-page"))
.GET()
.build();
var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());
}
}using System.Net;
var proxyUri = new Uri(
$"http://{Environment.GetEnvironmentVariable("WSA_PROXY_HOST")}:" +
$"{Environment.GetEnvironmentVariable("WSA_PROXY_PORT")}"
);
var proxy = new WebProxy(proxyUri) {
Credentials = new NetworkCredential(
Environment.GetEnvironmentVariable("WSA_PROXY_USERNAME"),
Environment.GetEnvironmentVariable("WSA_PROXY_PASSWORD")
)
};
using var client = new HttpClient(new HttpClientHandler { Proxy = proxy }) {
Timeout = TimeSpan.FromSeconds(30)
};
var body = await client.GetStringAsync(
"https://example.com/public-page"
);import { chromium } from "playwright";
const browser = await chromium.launch({
proxy: {
server: process.env.WSA_PROXY_SERVER,
username: process.env.WSA_PROXY_USERNAME,
password: process.env.WSA_PROXY_PASSWORD,
},
});
const page = await browser.newPage();
await page.goto("https://example.com/public-page");
console.log(await page.title());
await browser.close();Use the generated endpoint wherever your server-side client accepts a proxy configuration.
Operating ownership
The proxy endpoint changes the outbound route; it does not take over collection logic or downstream data quality.
WebScrapingAPI
WebScrapingAPI operates the residential proxy endpoint, network selection, and the configured rotation or session behavior.
A sua equipa
Your team operates the HTTP client, browser, crawler, request policy, retries, parsing, storage, and downstream quality rules.
Escolha
Select an eligible public target and define your request policy.
Configure
Generate the endpoint with authentication, country, and session behavior.
Request
Your client sends the request through the residential proxy endpoint.
Operar
Your team handles the target response, retries, parsing, storage, and quality checks.
Use the service only for eligible public webpages and review source terms, applicable requirements, and the Acordo de serviço before production use.
Use cases
The route can support collection from eligible public pages across these solution patterns. Your team remains responsible for target selection, collection policy, extraction, and data use.
Proxy choice
Residential controls are documented here. Confirm availability, locations, authentication, and session behavior for any datacenter or ISP option with WSA before choosing.
Decision | Residencial | Datacenter | ISP |
|---|---|---|---|
Network identity | Real residential IPs | Datacenter-origin IPs | ISP-associated IPs |
Documented here | Country choice, authentication, output, rotation, and sticky windows | Confirm the available controls | Confirm the available controls |
Continuity | Rotating by default; sticky for 3, 5, or 10 minutes | Confirm for the selected offer | Confirm for the selected offer |
Buyer fit | Your team owns the collector and needs residential routing controls | Evaluate when the target accepts datacenter-origin traffic | Evaluate when a workflow needs an ISP-associated route |
Swipe horizontally to compare all three proxy types.
Choose Residential Proxies when
your proxy-aware client is already working, your team wants to own request behavior, and a real residential IP route with documented rotation or short continuity matches the workload.
Pricing orientation
Residential proxy pricing is organized around traffic volume and plan allowances. Use the current pricing page for live plan details rather than relying on a copied rate.
Self-serve path
Create an account, generate the endpoint, and test the actual targets, countries, session behavior, response handling, and traffic profile you expect in production.
Evaluation checklist
FAQ
Use these answers to scope an integration, then verify the generated endpoint and current plan details before production.
Residential Proxies route requests from your proxy-aware HTTP client, browser, or crawler through real residential IPs. Your application still chooses the eligible public webpage and processes the response.
Use Residential Proxies when your team already operates the HTTP client, browser, crawler, retries, and parsing, and wants proxy-level control over country selection and short session continuity.
For username and password authentication, connect through pr.webscrapingapi.com:7777. The generated proxy URL combines that host with your credentials and selected options.
Rotation is the default. When session and rotation are omitted, each request can receive a different residential IP from the selected country or from country=random.
Sticky sessions use a stable session ID with a rotation value of 180, 300, or 600 seconds, corresponding to 3, 5, or 10 minutes. The maximum documented sticky window is 10 minutes.
Use country=random for any available documented location. The explicitly documented country codes are US, GB, DE, FR, CA, AU, and NL.
You can authenticate with a username and password in the generated endpoint or use a whitelisted IP with its documented country host and port. Keep credentials and generated endpoints server-side.
The endpoint generator provides Host:port, HTTP, HTTPS, and SOCKS5 output. Choose the format accepted by your HTTP client, browser, or crawler.
WebScrapingAPI operates the residential proxy endpoint, network selection, and the configured rotation or session behavior. Your team operates the client and every collection, parsing, storage, and quality decision around it.
Confirm source eligibility, your request policy, authentication, country choice, session behavior, retry rules, current plan terms, and target-response handling. Review the Service Agreement and test representative public pages before scaling.
Bring your collector
Start with the client you already use, one country choice, and a representative rotating or sticky workflow.