A rotating residential proxy is built for scale: a new IP for every request, or for a sticky session of up to 30 minutes. That is exactly wrong for a different kind of job: staying logged into an account all day, keeping a checkout or monitoring session alive for hours, or managing a store’s seller account from the same place every time. For those, the site expects one consistent visitor, and a changing IP looks like a stolen session.
ISP proxies are made for this. Each one stays in the city and on the internet provider you choose for the whole billing period. But a good proxy is only half of the setup. The other half is making sure everything else about the session stays just as consistent. This guide walks through the setup we recommend to customers, with code you can adapt.
When you need an ISP proxy instead of a rotating one
| Your job | What to use |
|---|---|
| Collecting many pages across many sites | Rotating residential proxies |
| A multi-step flow that finishes within 30 minutes | Residential sticky session |
| A session that has to last hours | ISP proxy |
| Staying logged into your own accounts day after day | ISP proxy |
| Checking how a site looks from a specific city and provider | ISP proxy |
The 30-minute line is the practical one. Residential sticky sessions on Shifter last up to 30 minutes. Anything longer, or anything that comes back to the same account tomorrow, belongs on an ISP proxy.
How Shifter’s ISP proxies work
- Every IP you place gets its own username, and all usernames on a plan share one password.
- Every proxy connects through the same host and port,
isp.shifter.io:443, over HTTP(S) or SOCKS5. - You choose the city and ISP (ASN) for each IP when you place it, from 120 countries.
- Each proxy keeps that city and ISP for as long as the plan is active.
- The IP address behind it can refresh over time, the way a home broadband connection gets a new address from its provider now and then. The city and the provider stay the same.
- Bandwidth is unlimited: plans are priced per IP.
That last-but-one point matters for persistent logins. Your setup should expect the address to change occasionally and rely on what stays the same: location, provider and the browser profile.
The setup, in five rules
1. One proxy per account, never shared. Give every account its own ISP proxy username and keep that pairing fixed. Two accounts on one IP look linked; one account across several IPs looks like it is being accessed from different places.
2. Place each IP where the account actually lives. If the account belongs to a store in Chicago, place its IP on a Chicago provider. A login from the right city and a residential provider looks like the account’s normal routine.
3. Keep a persistent browser profile per account. Cookies, local storage and saved sessions are what keep you logged in. Store them in a profile directory per account and reuse it every time. A fresh browser every run means a fresh login every run, which is exactly what triggers verification prompts.
4. Make the browser agree with the proxy. Timezone and language should match the exit’s location. The simplest way is to ask the exit where it is and set the browser from the answer. Our guide to matching proxy geo, timezone and locale covers the full list of signals.
5. Check the exit before you start. Confirm that the proxy is in the expected city and on the expected provider before opening the account. If it is not, stop instead of logging in from the wrong place.
The code
The module below puts the five rules into practice with Python and Playwright. It validates the account-to-proxy mapping, checks the exit through ip-info.com (our free IP geolocation API), and opens a persistent browser profile pinned to that account’s proxy, with the timezone taken from the exit itself.
from pathlib import Path
import requests
ISP_GATEWAY = "isp.shifter.io:443"
def validate_assignments(accounts):
"""One ISP proxy per account, and no proxy shared between accounts."""
problems, seen_accounts, owner = [], set(), {}
for a in accounts:
if a["account"] in seen_accounts:
problems.append(f"{a['account']}: listed twice")
seen_accounts.add(a["account"])
other = owner.setdefault(a["isp_username"], a["account"])
if other != a["account"]:
problems.append(f"{a['isp_username']}: shared by {other} and {a['account']}")
return problems
def check_exit(account, password, get=requests.get):
"""Ask the exit where it is, and compare with where this account belongs."""
proxy = f"http://{account['isp_username']}:{password}@{ISP_GATEWAY}"
info = get("http://ip-info.com/json", proxies={"http": proxy, "https": proxy}, timeout=20).json()
problems = []
if info.get("city") != account["city"]:
problems.append(f"city is {info.get('city')}, expected {account['city']}")
if info.get("asn") != account["asn"]:
problems.append(f"ASN is {info.get('asn')}, expected {account['asn']}")
return {"ip": info.get("ip"), "timezone": info.get("timezone"), "problems": problems}
def browser_options(account, password, exit_info, profile_root):
"""Persistent Chromium profile for one account, pinned to its own ISP proxy."""
return {
"user_data_dir": str(Path(profile_root) / account["account"]),
"proxy": {"server": f"http://{ISP_GATEWAY}",
"username": account["isp_username"], "password": password},
"timezone_id": exit_info["timezone"],
"locale": account["locale"],
"viewport": {"width": 1440, "height": 900},
}
def open_account(playwright, account, password, profile_root="profiles"):
"""Check the exit first; only then open the account's own browser profile."""
exit_info = check_exit(account, password)
if exit_info["problems"]:
raise RuntimeError(f"{account['account']}: " + "; ".join(exit_info["problems"]))
options = browser_options(account, password, exit_info, profile_root)
return playwright.chromium.launch_persistent_context(**options)And using it:
import os
from playwright.sync_api import sync_playwright
from isp_sessions import open_account, validate_assignments
ACCOUNTS = [
{"account": "store-us", "isp_username": "us-chicago-illinois-as7922-XXXXX",
"city": "Chicago", "asn": 7922, "locale": "en-US"},
{"account": "store-de", "isp_username": "de-berlin-berlin-as3320-XXXXX",
"city": "Berlin", "asn": 3320, "locale": "de-DE"},
]
password = os.environ["ISP_PASSWORD"]
problems = validate_assignments(ACCOUNTS)
if problems:
raise SystemExit("\n".join(problems))
with sync_playwright() as p:
browser = open_account(p, ACCOUNTS[0], password)
page = browser.pages[0] if browser.pages else browser.new_page()
page.goto("https://example.com/account")
# ... the account's work; cookies and storage persist in profiles/store-us
browser.close()Replace the XXXXX suffixes with the usernames from your plan page, which lists every username with its city and ISP. The profile directory, profiles/store-us in this example, is what keeps the account logged in between runs: back it up, and never point two accounts at the same one.
We tested the mapping check, the exit check (against recorded responses) and the browser options with Playwright’s Chromium. The exit check needs an active ISP plan to run against real proxies.
Keeping sessions alive for hours
- Keep a steady, human pace. A person in an account clicks, reads and waits. Bursts of hundreds of actions a minute look automated however good the proxy is.
- Reuse the open browser. Keep one browser open for the length of the work session instead of relaunching it for every task.
- Re-check the exit after a long pause. If you resume after hours, run the exit check again. Because the address can refresh, a site may occasionally ask you to confirm a login; with the same city, provider and profile, that is the same experience a real user has after their home router restarts.
- Do not switch an account to another proxy to fix a problem. If an account is challenged, a different city or provider makes it worse. Fix the cause, keep the pairing.
Troubleshooting
| Symptom | Likely cause | Fix |
|---|---|---|
407 Proxy Authentication Required | Wrong username or password | Copy the credentials again from the plan page; each IP has its own username |
| The exit check reports the wrong city | The username belongs to a different placement | Check the username against the list on the plan page |
| Logged out after every run | A new browser profile each time | Use a persistent profile directory per account |
| Repeated verification prompts | Timezone or language does not match the exit, or the account moved between proxies | Set the browser from the exit’s location and keep one proxy per account |
| Slow or failing requests from one IP | A problem with that placement | Run the connectivity check from the docs and contact support with the username |
A note on using accounts responsibly
These techniques are for accounts you are entitled to use: your own business accounts, your clients’ accounts with their permission, and test accounts on your own services. Every platform has its own rules on automation and on how many accounts one person or business may run. A consistent setup keeps legitimate work from being flagged; it is not a way around a platform’s rules, and it should not be used as one.
FAQ
Can I use rotating residential proxies for long sessions?
Only up to a point. Residential sticky sessions on Shifter last up to 30 minutes. For sessions that last longer, or for logins you return to every day, use an ISP proxy, which keeps its city and ISP for the whole billing period.
Does an ISP proxy’s IP address ever change?
The city and the ISP stay fixed while your plan is active. The IP address behind the proxy can refresh over time, like a home broadband connection. Build your setup around the location, the provider and a persistent browser profile, which stay the same.
How many accounts should share one ISP proxy?
One. Give each account its own proxy so that each looks like a separate household and no two accounts appear linked.
Do I need a persistent browser profile?
For logins, yes. The profile holds the cookies and storage that keep you signed in. Without it, every run starts as a new device and is far more likely to be asked for verification.
The bottom line
Long sessions and persistent logins need consistency, not rotation. Give each account its own ISP proxy placed in the account’s real city, keep one persistent browser profile per account, set the browser’s timezone and language from the exit, and check the exit before every start. With those in place, an account looks the same every day, which is all a site is checking for. Our comparison of ISP and residential proxies covers the wider choice between the two.