US ISP proxies: a provider address at server speed
These addresses belong to internet providers and sit in a datacenter. The platform sees a home provider and lets the request through, and you get a server channel. By default each request gets a new address, and an IP placed in the login makes the line static.
$ curl -x LOGIN:PASSWORD@gw.proxymix.net:9020 ifconfig.me 45.86.xxx.12 # USA | ISP proxies
A bigger order lowers the price per gigabyte
One order sets the tier, and that tier applies to all its gigabytes. Drag the slider to see the price and discount for your volume. Traffic stays on the balance for three months and threads have no limit.
| size of one order | 1–9 GB | 10–49 | 50–99 | 100–499 | 500–999 | 1000+ |
|---|---|---|---|---|---|---|
ISP proxiesUS providers | $1.49 | $1.39 | $1.29 | $1.15 | $1.05 | $0.95 |
What the plan includes
ISP proxiesprovider addresses on servers- Targeting
- US addresses
- Networks
- American home providers, no hosting companies
- Session
- Rotation per request or a static IP written into the login
- Connect over
- HTTP and SOCKS5
- Threads
- No limit at server speed
- Lines
- Up to 5,000 in a list, recreate it by hand or by timer every N minutes
- Login
- Login and password sit right in the line
- Payment
- Per gigabyte, the rest stays valid for 3 months
Sessions, rotation and targeting
The IP belongs to a home internet provider and physically sits in a datacenter. The platform sees the provider and lets you in, and the channel stays a server one.
A regular line takes a new address from the pool of US providers on every request. Write an IP into the login and the line exits only from it while that address remains in the pool, usually for days.
The addresses belong to US home providers, among them RCN and Grande. The list has no hosting companies, so a platform sees an ordinary subscriber.
You pick the list refresh interval when you create it in the dashboard, and the addresses always stay American. The line format is host:port:login:password, and a static line takes the login-ip-address form.
What people use it for
Platforms that cut off datacenters and let a provider address through.
Long collection sessions at server speed with no dropouts.
A home provider in the header and a stable channel under load.
Static ISP lines with a single command
A login like login-ip-203.0.113.7 ties the line to that address. The script builds such a list by itself: it asks the pool for the number of IPs you want, verifies each one and writes the lines to hold.txt. You need only bash and curl, and on Windows Git Bash and WSL both work.
# 10 lines that hold one IP each, over SOCKS5, saved to hold.txt
curl -s https://proxymix.net/res/files/isp-hold.sh | bash -s -- HOST:PORT:LOGIN:PASSWORD 10
# or over HTTP
curl -s https://proxymix.net/res/files/isp-hold.sh | bash -s -- http://HOST:PORT:LOGIN:PASSWORD 10
# print the IP behind every saved line
curl -s https://proxymix.net/res/files/isp-hold.sh | bash -s -- testShow the isp-hold.sh code
#!/usr/bin/env bash
# Turn a rotating ISP line into a list of lines that hold one IP each, then test that list.
ECHO_HOST=http://icanhazip.com
LIST=hold.txt
FORCE_PROTO=
ON_TTY=no
[ -t 2 ] && ON_TTY=yes
die_usage() {
cat >&2 <<'END'
isp-hold.sh [--proto socks5|http] HOST:PORT:LOGIN:PASSWORD [N]
collect N addresses (10 by default) and write lines that hold them to hold.txt
isp-hold.sh test [--proto socks5|http] [FILE]
print the IP behind every line of FILE (hold.txt by default)
Protocol: the prefix of the line (socks5:// or http://), then --proto, then SOCKS5.
END
exit 1
}
read_line() {
local raw=$1 proto=$FORCE_PROTO
PREFIX=
if [[ $raw =~ ^(http|socks5h?)://(.+)$ ]]; then
proto=${BASH_REMATCH[1]}
raw=${BASH_REMATCH[2]}
PREFIX=$proto://
fi
IFS=: read -r SRV PORT NAME PASS <<< "$raw"
if [ "$proto" = http ]; then
PROXY=http://$SRV:$PORT
else
PROXY=socks5h://$SRV:$PORT
fi
}
ask_ip() {
curl -s --max-time 15 --proxy "$PROXY" --proxy-user "$1:$PASS" "$ECHO_HOST" < /dev/null | tr -d '[:space:]'
}
meter() {
[ "$ON_TTY" = yes ] || return 0
local cur=$1 max=$2 cols=26 fill gap
fill=$((cur * cols / max))
gap=$((cols - fill))
printf '\r%3d%% %s%s %d/%d ' $((cur * 100 / max)) \
"$(printf '%*s' "$fill" '' | tr ' ' '=')" "$(printf '%*s' "$gap" '' | tr ' ' '-')" "$cur" "$max" >&2
}
wipe() {
[ "$ON_TTY" = yes ] && printf '\r\033[K' >&2
return 0
}
collect() {
[ -n "$1" ] || die_usage
local need=${2:-10} kept=0 tries=0 alive=no taken=' ' ip
[[ $need =~ ^[1-9][0-9]*$ ]] || die_usage
read_line "$1"
: > "$LIST"
meter 0 "$need"
while ((kept < need && tries < need * 3)); do
((tries += 1))
ip=$(ask_ip "$NAME")
if [[ ! $ip =~ ^[0-9]+(\.[0-9]+){3}$ ]]; then
if [ "$alive" = no ] && ((tries >= 3)); then
wipe
echo "No answer from $PROXY. Make sure the port and protocol are right." >&2
exit 1
fi
continue
fi
alive=yes
[[ $taken == *" $ip "* ]] && continue
taken+="$ip "
[ "$(ask_ip "$NAME-ip-$ip")" = "$ip" ] || continue
printf '%s\n' "$PREFIX$SRV:$PORT:$NAME-ip-$ip:$PASS" >> "$LIST"
((kept += 1))
meter "$kept" "$need"
done
wipe
echo "$kept of $need lines written to $LIST"
}
test_list() {
local src=${1:-$LIST} max cur=0 fine=0 line held out
[ -r "$src" ] || { echo "No such file: $src" >&2; exit 1; }
max=$(grep -c . "$src")
((max > 0)) || { echo "Empty file: $src" >&2; exit 1; }
meter 0 "$max"
while IFS= read -r line || [ -n "$line" ]; do
line=${line%$'\r'}
[ -n "$line" ] || continue
read_line "$line"
held=none
[[ $NAME =~ -ip-([0-9.]+)$ ]] && held=${BASH_REMATCH[1]}
out=$(ask_ip "$NAME")
((cur += 1))
wipe
if [ "$out" = "$held" ]; then
((fine += 1))
printf 'ok %s\n' "$held"
else
printf 'miss %s answered %s\n' "$held" "${out:-nothing}"
fi
meter "$cur" "$max"
done < "$src"
wipe
echo "$fine of $cur lines hold their IP"
}
ACTION=collect
if [ "$1" = test ]; then
ACTION=test_list
shift
fi
if [ "$1" = --proto ]; then
FORCE_PROTO=$2
shift 2
[[ $FORCE_PROTO =~ ^(socks5|http)$ ]] || die_usage
fi
"$ACTION" "$@"Replace HOST:PORT:LOGIN:PASSWORD with a line from the dashboard. The script uses SOCKS5 by default. For HTTP, put http:// before the line or add --proto http. The test command shows which address answered on each line.
ISP proxies in the USA
The plan in brief
How does ISP differ from a datacenter?
The address belongs to a home provider, so platforms trust it like a residential one, and the channel stays a server one.
How does ISP differ from residential?
Residential addresses work through devices of real people, and ISP addresses sit on provider servers. ISP runs faster and steadier, with a narrower pool and addresses only in the USA.
Does the address change?
In a regular line, yes: a new IP on every request. Add -ip- and the address to the end of the login, say login-ip-203.0.113.7, and that line turns static: the IP holds while it stays in the pool. This page’s script builds a list of such lines.
Which countries does it cover?
Only the USA: the line gives you an American address right away. “Residential · Country” and “Mobile 4G/5G” cover the other countries.
When does the traffic expire?
Three months after purchase, with no limit on threads.
Can I try it?
Yes, from $1.49 per gigabyte, and the price falls with volume.
Compare with other types
Residential · Countryhome IPs of real users
Residential · City+home IPs with precise targeting
Mobile 4G/5Gcellular carrier addresses
Datacenter IPv4server addresses
Datacenter IPv6cheapest traffic
Unlimited proxiespay for threads and termStart with 1 GB
Top up your balance, create a list for the country you need and test the pool on your target site. If it works, order more at the tier discount.
