Proxies with Unlimited Bandwidth

# Measure bandwidth & throughput through the unlimited endpoint
curl -x unlimited.resproxy.io:8000 \
  -U "user:pass" \
  -o dataset.tar.gz \
  -w "downloaded: %{size_download} bytes\nspeed: %{speed_download} B/s\ntotal: %{time_total}s\n" \
  https://cdn.example.com/datasets/full-dump.tar.gz

# No data caps — pull as many GB as you need, throughput stays flat
curl -x unlimited.resproxy.io:8000 -U "user:pass" \
  -O https://releases.example.com/archive-2026.zip

# Stream a multi-GB file through the proxy with a live progress bar
import requests
from tqdm import tqdm

URL = "https://cdn.example.com/datasets/full-dump.tar.gz"
PROXY = "http://user:pass@unlimited.resproxy.io:8000"

with requests.get(URL, stream=True, timeout=None,
                  proxies={"http": PROXY, "https": PROXY}) as r:
    r.raise_for_status()
    total = int(r.headers.get("content-length", 0))
    with open("full-dump.tar.gz", "wb") as f, \
         tqdm(total=total, unit="B", unit_scale=True,
              desc="download") as bar:
        for chunk in r.iter_content(chunk_size=1024 * 1024):  # 1 MiB chunks
            f.write(chunk)
            bar.update(len(chunk))

# Zero bandwidth caps — works the same whether the file is 1 GB or 1 TB.

# Recursive mirror over an unlimited-bandwidth proxy
export http_proxy="http://user:pass@unlimited.resproxy.io:8000"
export https_proxy="http://user:pass@unlimited.resproxy.io:8000"

wget \
  --recursive \
  --level=5 \
  --no-clobber \
  --page-requisites \
  --html-extension \
  --convert-links \
  --restrict-file-names=windows \
  --domains example.com \
  --no-parent \
  --limit-rate=0 \
  https://example.com/archive/

# limit-rate=0 -> let the proxy run at full line speed, no throttling.

# High-bandwidth video stream capture through the proxy
# ffmpeg reads HLS via http_proxy env, no per-stream bandwidth cap

export http_proxy="http://user:pass@unlimited.resproxy.io:8000"
export https_proxy="http://user:pass@unlimited.resproxy.io:8000"

ffmpeg \
  -loglevel info \
  -stats \
  -i "https://stream.example.com/live/master.m3u8" \
  -c copy \
  -bsf:a aac_adtstoasc \
  -t 02:00:00 \
  stream-capture.mp4

# 2h HD capture = 5-8 GB of proxied traffic — charged as $0 extra.

// Stream huge response bodies straight to disk — no buffering, no caps
import { createWriteStream } from 'node:fs';
import { pipeline } from 'node:stream/promises';
import fetch from 'node-fetch';
import { HttpsProxyAgent } from 'https-proxy-agent';

const agent = new HttpsProxyAgent(
  'http://user:pass@unlimited.resproxy.io:8000'
);

const res = await fetch(
  'https://cdn.example.com/datasets/full-dump.tar.gz',
  { agent }
);
if (!res.ok) throw new Error(`HTTP ${res.status}`);

const total = Number(res.headers.get('content-length') ?? 0);
let received = 0;

res.body.on('data', (chunk) => {
  received += chunk.length;
  process.stdout.write(
    `\r${(received / 1e9).toFixed(2)} / ${(total / 1e9).toFixed(2)} GB`
  );
});

await pipeline(res.body, createWriteStream('full-dump.tar.gz'));

#!/usr/bin/env bash
# Bulk parallel downloader — no bandwidth budget to worry about
set -euo pipefail

PROXY="http://user:pass@unlimited.resproxy.io:8000"
CONCURRENCY=16
URLS_FILE="urls.txt"
OUT_DIR="./downloads"
mkdir -p "$OUT_DIR"

# xargs fans out to 16 parallel curls, all going through the same
# unlimited endpoint — terabytes/day is a normal workload.
cat "$URLS_FILE" | xargs -n1 -P"$CONCURRENCY" -I{} \
  curl --silent --show-error --fail \
       --proxy "$PROXY" \
       --retry 5 --retry-delay 2 \
       --output "$OUT_DIR/$(basename "{}")" \
       "{}"

echo "Done. Total bytes:"
du -sh "$OUT_DIR"