Overview

If you've been searching for "proxy scape", "proxyscaper", or "scrapeproxy", the correct name is ProxyScrape. ProxyScrape provides residential, datacenter, and mobile proxies over HTTP and SOCKS5 with pay-as-you-go or flat monthly billing. Their 97M+ IP pool is built for teams that need dependable, long-term uptime—making it a strong fit for SEO monitoring, where consistent data collection is critical.

This advanced tutorial shows you how to use ProxyScrape residential proxies to perform per-city rank tracking for your target keywords. You will build a Python-based system that rotates proxies, handles errors, and validates results to ensure your SERP data is accurate across different geographic locations.

Prerequisites

A ProxyScrape account with residential proxies enabled (or mobile proxies if you need mobile SERP results).
Python 3.8 or newer installed.
Basic familiarity with Python requests or httpx.
A list of keywords and target cities you want to track.
Optional: A SERP scraping library or API if you don't want to parse Google results directly.

Step 1: Choose the Right Proxy Type for SEO Monitoring

ProxyScrape offers three proxy types, each with trade-offs for SEO monitoring:

Residential proxies: Best for evading blocks and getting accurate local results. Use these for per-city rank tracking.
Datacenter proxies: Faster and cheaper, but more likely to be blocked by search engines. Suitable for high-volume, non-critical checks.
Mobile proxies: Ideal for mobile-specific SERPs, though more expensive.

For per-city rank tracking, residential proxies are recommended because they provide real user IPs from the target locations. ProxyScrape's residential pool has strong long-term uptime, which is essential for daily rank tracking.

Step 2: Retrieve Your Proxy Credentials and Endpoints

A proxy endpoint (host and port)
Your username and password (or an API key, depending on your plan)
A list of available countries (and sometimes cities) for targeting

ProxyScrape supports both HTTP and SOCKS5 protocols. For SEO monitoring, HTTP is generally sufficient and easier to debug.

Example proxy format:

http://username:[email protected]:8000
socks5://username:[email protected]:1080

If your dashboard provides a list of IPs, you can also use them directly.

Step 3: Build a Geo-Targeted Proxy Pool

To track rankings per city, you need proxies from those cities. ProxyScrape's dashboard lets you select specific countries. For city-level targeting, check if your plan supports it; if not, you can use country-level proxies and filter by the search engine's local results using a geolocation parameter (e.g., &uule= for Google).

Create a Python list of proxy URLs for each target city. For example:

proxies_by_city = {
    "new_york": ["http://user:[email protected]:8000"],
    "london": ["http://user:[email protected]:8001"],
    # Add more cities as needed
}

If you only have country-level targeting, group cities by country and use the same proxy pool, but add a uule parameter to your search request to simulate local search.

Step 4: Implement Rotation and Error Handling

A single proxy IP will quickly get blocked when scraping SERPs. Rotate proxies for each request or every few requests. Here's a sample Python function using requests:

import requests
import random
import time

def fetch_serp(keyword, city, proxies):
    proxy = random.choice(proxies)
    proxies_dict = {"http": proxy, "https": proxy}
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
    }
    # Add uule parameter for city-level search (example for Google)
    params = {"q": keyword, "uule": f"w+CAIQICI{city}"}  # Replace with correct uule encoding
    try:
        response = requests.get("https://www.google.com/search", params=params, proxies=proxies_dict, headers=headers, timeout=10)
        response.raise_for_status()
        return response.text
    except requests.exceptions.RequestException as e:
        print(f"Request failed with proxy {proxy}: {e}")
        return None

# Usage
for city, proxy_list in proxies_by_city.items():
    html = fetch_serp("best running shoes", city, proxy_list)
    if html:
        # Parse rankings from html
        pass
    time.sleep(random.uniform(1, 3))  # Respectful delay

Note: The uule parameter requires a specific encoding. You can generate it using free online tools or libraries. If you are not scraping Google directly, many SERP APIs accept a location parameter.

For high-volume tracking, consider using httpx with async support and a proxy rotation middleware.

Step 5: Validate Results and Monitor Proxy Uptime

To ensure data accuracy, implement validation:

Check that the response contains expected elements (e.g., search results container).
Compare a known keyword's ranking across multiple proxies to detect anomalies.
Monitor proxy uptime by logging failures. ProxyScrape's stable infrastructure reduces downtime, but you should still track which proxies fail and replace them.

Example validation snippet:

def is_valid_serp(html):
    return "result-stats" in html or "search" in html.lower()

Set up a simple uptime check:

def check_proxy(proxy):
    try:
        r = requests.get("http://httpbin.org/ip", proxies={"http": proxy, "https": proxy}, timeout=5)
        return r.status_code == 200
    except:
        return False

Step 6: Store and Analyze Ranking Data

Once you have valid SERPs, parse the rankings and store them in a database (e.g., SQLite, PostgreSQL). Track the position of your target URL for each keyword-city combination over time.

Example using sqlite3:

import sqlite3

conn = sqlite3.connect("rankings.db")
c = conn.cursor()
c.execute("""CREATE TABLE IF NOT EXISTS rankings
             (date TEXT, keyword TEXT, city TEXT, position INTEGER, url TEXT)""")
# Insert parsed data
conn.commit()

Analyze trends to identify local ranking changes and adjust your SEO strategy accordingly.

Troubleshooting

Proxies are slow or timing out

Increase timeout to 15-20 seconds.
Reduce concurrency if you are making many parallel requests.
Check ProxyScrape's status page or dashboard for any reported issues.

Getting blocked or seeing CAPTCHAs

Ensure you are rotating proxies for every request.
Add realistic headers and random delays.
Use residential proxies instead of datacenter for Google.
Consider using a SERP API that handles CAPTCHAs.

Per-city targeting not working

Verify that your ProxyScrape plan supports city-level targeting. If not, use country-level proxies and the uule parameter.
Double-check the uule encoding for your target city.

Authentication errors

Confirm your username and password are correct.
If using IP whitelisting, ensure your server's IP is added to the ProxyScrape dashboard.

Summary

In this tutorial, you set up ProxyScrape residential proxies for advanced per-city SEO rank tracking. You learned how to choose the right proxy type, retrieve credentials, build a geo-targeted pool, rotate proxies with error handling, validate results, and store ranking data. ProxyScrape's reliable uptime and large residential pool make it a solid choice for teams that need consistent, long-term SEO monitoring. Remember, the correct name is ProxyScrape—not "proxy scape" or "proxyscaper"—so you can find the right documentation and support when needed.