Exits become the bottleneck at scale
Corpora run to tens of millions of pages. A few cloud-server IPs can't carry that, 429s pile up and incremental refreshes keep slipping.
Gather public text, images and video for model training from residential exits in each language market, on sessions you control.
Common platforms and tools
Corpora run to tens of millions of pages. A few cloud-server IPs can't carry that, 429s pile up and incremental refreshes keep slipping.
Multilingual models need original text from local sites. Visit from one place and many sites serve only their international or English edition.
A multimodal batch can mean terabytes of downloads, and per-GB billing makes that hard to budget.
Paged comments and filtered lists take several requests to read through; if the exit changes halfway, the pages stop lining up.
Exits come from real home broadband in 195+ countries and regions, so crawl load spreads across the whole pool instead of a few servers.
Pull English text through US or UK exits, Japanese through Japan and German through Germany; in the US you can go down to 36 states and 112 cities.
Unrelated pages take a fresh exit on every request; paged comments and filtered lists hold one IP with a sticky session until they are read through.
Dynamic residential plans don't cap concurrent connections, so add workers freely and set the pace by what each target site can handle.
Text suits the Traffic plan (From $0.8/GB), whose packs don't expire; terabyte-scale image, audio and video downloads suit Bandwidth plans with 100Mbps–1Gbps dedicated and no traffic cap under fair use.
HTTP, HTTPS and SOCKS5 with username-and-password or IP-allowlist auth, so Scrapy, HTTPX, Playwright or an in-house crawler needs only its proxy setting changed.
After purchase you get a connection address and port to put in place of the placeholders. Confirm the exit with cURL, fetch text concurrently with HTTPX, and hand whole-site crawls to Scrapy.
GATEWAY, PORT, USER and PASS are placeholders: swap in the connection details you get after purchase. IP-allowlist auth needs no USER or PASS.
-x sets the proxy and -I fetches headers only, enough to confirm the connection and auth work. socks5h:// uses SOCKS5 with hostnames resolved by the proxy; with IP-allowlist auth, drop USER:PASS@.
# Check connectivity and auth, headers only
curl -I -x http://USER:PASS@GATEWAY:PORT https://example.com/
# SOCKS5, hostnames resolved by the proxy
curl -I -x socks5h://USER:PASS@GATEWAY:PORT https://example.com/ AsyncClient takes the proxy argument (HTTPX 0.26+); the Semaphore caps requests in flight, so tune it to what the target site can take. Name your crawler and a contact in the User-Agent so site owners can identify it.
import asyncio
import httpx
PROXY = "http://USER:PASS@GATEWAY:PORT"
UA = "ExampleCorpusBot/1.0 (+https://example.com/bot)"
URLS = ["https://example.com/a", "https://example.com/b"]
async def fetch(client, sem, url):
async with sem:
r = await client.get(url, timeout=30)
return url, r.status_code, len(r.text)
async def main():
sem = asyncio.Semaphore(8)
client = httpx.AsyncClient(proxy=PROXY, headers={"User-Agent": UA})
async with client:
jobs = [fetch(client, sem, u) for u in URLS]
for row in await asyncio.gather(*jobs):
print(row)
asyncio.run(main()) Follows in-site links and collects body text, with proxy set in each request's meta. ROBOTSTXT_OBEY stays on, AutoThrottle sets the pace and DEPTH_LIMIT bounds the crawl; async def start() needs Scrapy 2.13+.
import scrapy
PROXY = "http://USER:PASS@GATEWAY:PORT"
class CorpusSpider(scrapy.Spider):
name = "corpus"
allowed_domains = ["example.com"]
custom_settings = {
"ROBOTSTXT_OBEY": True,
"AUTOTHROTTLE_ENABLED": True,
"DEPTH_LIMIT": 3,
}
async def start(self):
url = "https://example.com/"
yield scrapy.Request(url, meta={"proxy": PROXY})
def parse(self, response):
text = " ".join(response.css("p::text").getall())
yield {"url": response.url, "text": text}
for href in response.css("a::attr(href)").getall():
yield response.follow(href, meta={"proxy": PROXY}) Text and multilingual corpora run on a residential proxy pool billed per GB; steady media downloads move to bandwidth; data feeds that register your source IP take a static IP.
Dynamic residential · Traffic
Billed per GB with unlimited concurrency and country targeting for each language; packs don't expire, which suits corpus work that moves in batches.
From $0.8/GB
Learn more · Dynamic residential · TrafficDynamic residential · Bandwidth
30-day terms with 100Mbps–1Gbps dedicated and no traffic cap under fair use, so terabyte downloads cost a fixed amount. Sources in the US, UK, Germany, France, Japan and South Korea need Flagship.
100Mbps / $980/30 days
Learn more · Dynamic residential · BandwidthDatacenter IP
When a licensed data source asks you to register a source IP, give it a dedicated datacenter IP: the address stays fixed for the lease and large files cost less to pull.
$3/IP/month
Learn more · Datacenter IPStatic residential · Short-term
When someone needs to review a sample of source pages before ingestion, use short-term IPs: dedicated for 1–24 hours, sold in IP packs that don't expire.
From $0.17/IP
Learn more · Static residential · Short-termCommon sources are public web pages, open datasets, licensed data and synthetic data. Proxies serve the public-web part: your crawler's requests leave from residential networks in the matching language market, which spreads load and returns the local edition of each page. Licensed data and anything behind a login go through official APIs or data partnerships.
Text pages are small, so the per-GB Traffic plan (From $0.8/GB) usually covers them, and its packs don't expire. For large volumes of images, audio, video or PDFs, a Bandwidth plan (100Mbps / $980/30 days, Basic) keeps costs predictable. Run a sample batch on a small pack first and decide from the real volume.
Follow robots.txt and the site's terms, since many sites state separately whether crawling for AI training is allowed. Name your crawler and a contact in the User-Agent, keep the rate moderate, and strip personal data before ingestion. A proxy only decides where requests come from; it doesn't change what a site permits, so ask a lawyer about your specific project.
News, forum and encyclopedia pages written for ordinary readers fit residential IPs, which return the version local readers get. Open data APIs, mirrors and large file downloads suit a dedicated datacenter IP, with high throughput at a lower price.
Use them for content that takes several requests to read: paged comments, filtered lists and pages you reach after choosing a language. A sticky session keeps that run of requests on one exit, while unrelated pages still rotate on every request.
Dynamic residential plans don't cap concurrency, so the limit is usually the target site. Set a per-domain cap and interval, back off as Retry-After says when you see a 429, and run a small trial before scaling the cluster once the data looks right.
Yes. It speaks HTTP, HTTPS and SOCKS5 with username-and-password or IP-allowlist auth; give every worker the same connection address and port, and NexIP handles exit rotation, so there's no IP list to maintain.
Still have a question?