Come evitare blocchi di Google durante lo scorrimento SERP

Come Google rileva i grattacieli SERP

Google investe fortemente nella protezione dei suoi risultati di ricerca da accesso automatizzato. Prima di poter evitare blocchi, è necessario capire i metodi di rilevamento che Google impiega. Ogni metodo mira un segnale diverso, e efficace raschiatura SERP richiede indirizzare tutti loro contemporaneamente.

Per una panoramica completa dell'architettura di raschiatura SERP con i proxy, vedere il nostro Raschiatura SERP con guida proxy.

Rilevazione basata su IP

La prima linea di difesa è l'analisi IP. Google traccia volume di query per indirizzo IP e bandiere quelli che superano i normali modelli di ricerca umana. I segnali specifici includono:

• Frequenza di richiesta: Più di un paio di ricerche al minuto da una singola velocità di attivazione IP
• reputazione IP: Gli intervalli IP noti del datacenter ricevono un controllo immediato
• Incongruenza geografica: Un IP proveniente dalla Germania che fa domande in lingua inglese chiamate USA solleva bandiere
• Analisi ASN: Google identifica blocchi IP appartenenti a fornitori di hosting vs ISPs

Sfogliatore Impronte

Oltre gli indirizzi IP, Google esamina la richiesta stessa per i segni di automazione:

Per approfondire queste tecniche, leggi il nostro articolo su come i sistemi anti-bot rilevano i proxy.

Analisi comportamentale

Google analizza i modelli attraverso le richieste per rilevare l'automazione:

• Richiesta tempistiche: Intervalli perfettamente coerenti tra richieste (ad esempio, esattamente 3 secondi a parte) sono innaturali
• Modelli di query: Scraping parole chiave in ordine alfabetico o in sequenze prevedibili sembra automatizzato
• Comportamento di sessione: Gli utenti reali sfogliano più pagine, cliccano i risultati, e passano la lettura del tempo — raschietti solo cattura SERPs
• Modelli di volume: Spicchi improvvisi in volume di query da IP correlati suggeriscono raschiatura coordinata

I tre strati della strategia anti-Block

Evitare blocchi di Google richiede un approccio stratificato. Nessuna tecnica è sufficiente da sola.

Livello 1: Infrastrutture proxy

La vostra scelta del proxy è la base della vostra strategia anti-blocco. Prossi residenziali ProxyHat fornire la diversità IP e il livello di fiducia necessario per il raschiamento SERP sostenuto.

Livello 2: Richiesta di configurazione

Ogni richiesta HTTP deve apparire come viene da un browser reale. Intestazioni, cookie e tempistiche tutti devono essere realistici.

Livello 3: schemi comportamentali

Il modello generale della vostra attività di raschiamento deve imitare il comportamento di ricerca naturale. Ciò significa ritardi randomizzati, sequenze di query varie e volumi di richiesta appropriati.

Punti positivi: Your First Defense

Il cambiamento singolo più efficace che puoi fare è passare dal datacenter al Prossi residenzialiEcco perché gli IP residenziali sono fondamentalmente diversi dalla prospettiva di Google:

• Gli IP residenziali appartengono a ISP reali (Comcast, AT&T, BT, Deutsche Telekom), non fornitori di cloud
• Google non può bloccare gli intervalli IP residenziali senza bloccare gli utenti legittimi
• Ogni IP ha una cronologia di navigazione e una reputazione costruita dal suo vero utente
• Gli IP residenziali supportano il geo-targeting a livello di città per i SERP imprecisi sul luogo

Configurazione proxy per SERP Scraping

import requests
# ProxyHat residential proxy with automatic rotation
PROXY_URL = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
session = requests.Session()
session.proxies = {
    "http": PROXY_URL,
    "https": PROXY_URL,
}
# Each request automatically gets a new residential IP
response = session.get(
    "https://www.google.com/search",
    params={"q": "best proxy service", "num": 10, "hl": "en", "gl": "us"},
    headers={
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.9",
        "Accept-Encoding": "gzip, deflate, br",
        "DNT": "1",
        "Connection": "keep-alive",
        "Upgrade-Insecure-Requests": "1",
    },
    timeout=15,
)

Fare riferimento al Documentazione ProxyHat per impostazioni di rotazione e sessione avanzate.

Intestazioni di richiesta realistiche

Le intestazioni incomplete o inconsistenti sono una delle ragioni più comuni che si bloccano. Ecco un completo set di intestazioni realistiche:

import random
# Rotate between realistic User-Agent strings
USER_AGENTS = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Gecko/20100101 Firefox/125.0",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.3 Safari/605.1.15",
]
def get_headers():
    ua = random.choice(USER_AGENTS)
    headers = {
        "User-Agent": ua,
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.9",
        "Accept-Encoding": "gzip, deflate, br",
        "DNT": "1",
        "Connection": "keep-alive",
        "Upgrade-Insecure-Requests": "1",
        "Sec-Fetch-Dest": "document",
        "Sec-Fetch-Mode": "navigate",
        "Sec-Fetch-Site": "none",
        "Sec-Fetch-User": "?1",
        "Cache-Control": "max-age=0",
    }
    # Firefox has different Sec-Ch headers
    if "Firefox" not in ua:
        headers["Sec-Ch-Ua"] = '"Chromium";v="124", "Google Chrome";v="124", "Not-A.Brand";v="99"'
        headers["Sec-Ch-Ua-Mobile"] = "?0"
        headers["Sec-Ch-Ua-Platform"] = '"Windows"' if "Windows" in ua else '"macOS"'
    return headers

Tieni sempre aggiornato le stringhe User-Agent con le versioni attuali del browser. Inviare un Chrome 90 User-Agent nel 2026 è una bandiera rossa immediata.

Limitare e richiedere il temporizzazione

Il modello delle vostre richieste conta tanto quanto le richieste stesse. Ecco le strategie di tempistica provate:

Delays casuali

Non utilizzare mai intervalli fissi tra le richieste. Invece, randomizzare ritardi per imitare il comportamento di ricerca umana:

import time
import random
def human_delay():
    """Generate a realistic delay between searches."""
    # Base delay: 3-8 seconds (normal browsing pace)
    base = random.uniform(3, 8)
    # Occasionally add longer pauses (simulating reading results)
    if random.random() < 0.15:
        base += random.uniform(10, 30)
    # Rare very short delays (rapid refinement searches)
    if random.random() < 0.05:
        base = random.uniform(1, 2)
    return base
# Usage in scraping loop
for keyword in keywords:
    result = scrape_serp(keyword)
    delay = human_delay()
    time.sleep(delay)

Richiesta Guida del volume

Gestione dei CAPTCHA e dei blocchi

Anche con le migliori precauzioni, occasionalmente si incontrano blocchi. Costruire il raschietto per gestirli con grazia.

Rilevamento dei blocchi

def is_blocked(response):
    """Check if Google has blocked or challenged the request."""
    # HTTP 429: Rate limited
    if response.status_code == 429:
        return "rate_limited"
    # HTTP 503: Service unavailable (temporary block)
    if response.status_code == 503:
        return "service_unavailable"
    text = response.text.lower()
    # CAPTCHA detection
    if "captcha" in text or "recaptcha" in text:
        return "captcha"
    # Unusual traffic message
    if "unusual traffic" in text or "automated queries" in text:
        return "unusual_traffic"
    # Empty or suspicious results
    if "did not match any documents" in text and len(text) < 5000:
        return "empty_suspicious"
    return None

Strategia di riprovazione

import time
import random
def scrape_with_retry(keyword, max_retries=3):
    """Scrape a SERP with automatic retry on blocks."""
    for attempt in range(max_retries):
        proxy_url = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
        proxies = {"http": proxy_url, "https": proxy_url}
        response = requests.get(
            "https://www.google.com/search",
            params={"q": keyword, "num": 10, "hl": "en", "gl": "us"},
            headers=get_headers(),
            proxies=proxies,
            timeout=15,
        )
        block_type = is_blocked(response)
        if block_type is None:
            return parse_results(response.text)
        if block_type == "rate_limited":
            # Exponential backoff
            wait = (2 ** attempt) * 5 + random.uniform(0, 5)
            print(f"Rate limited. Waiting {wait:.1f}s (attempt {attempt + 1})")
            time.sleep(wait)
        elif block_type == "captcha":
            # Switch to a new IP and wait
            print(f"CAPTCHA detected. Rotating IP and waiting...")
            time.sleep(random.uniform(10, 20))
        else:
            # Generic block: wait and retry
            time.sleep(random.uniform(5, 15))
    return None  # All retries exhausted

Consistenza geografica

Una misura di anti-detezione sottile ma importante garantisce la coerenza geografica attraverso i parametri di richiesta:

• Se il tuo IP proxy è negli Stati Uniti, impostare gl=us e hl=en
• Abbina l'intestazione Accept-Language al locale di destinazione
• Utilizzare una stringa User-Agent per una combinazione OS/browser comune in quel paese
• Impostare i tempi di richiesta appropriati per il fuso orario

ProxyHat funzione di geo-targeting consente di selezionare i proxy da paesi e città specifici, rendendolo semplice per mantenere questa coerenza. Scopri di più sull'utilizzo delle richieste localizzate nella nostra guida raschiamento senza bloccarsi.

Node.js Attuazione antiblocco

Ecco l'equivalente strategia anti-blocco implementata in Node.js:

const axios = require('axios');
const cheerio = require('cheerio');
const { HttpsProxyAgent } = require('https-proxy-agent');
const USER_AGENTS = [
  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
  'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Gecko/20100101 Firefox/125.0',
];
function getRandomUA() {
  return USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)];
}
function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}
async function scrapeWithRetry(keyword, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const agent = new HttpsProxyAgent('http://USERNAME:PASSWORD@gate.proxyhat.com:8080');
    try {
      const { data, status } = await axios.get('https://www.google.com/search', {
        params: { q: keyword, num: 10, hl: 'en', gl: 'us' },
        headers: {
          'User-Agent': getRandomUA(),
          'Accept': 'text/html,application/xhtml+xml',
          'Accept-Language': 'en-US,en;q=0.9',
        },
        httpsAgent: agent,
        timeout: 15000,
        validateStatus: () => true,
      });
      if (status === 429) {
        const wait = Math.pow(2, attempt) * 5000 + Math.random() * 5000;
        console.log(`Rate limited. Waiting ${(wait/1000).toFixed(1)}s`);
        await sleep(wait);
        continue;
      }
      if (data.toLowerCase().includes('captcha')) {
        console.log('CAPTCHA detected. Rotating IP...');
        await sleep(10000 + Math.random() * 10000);
        continue;
      }
      return cheerio.load(data);
    } catch (err) {
      console.log(`Attempt ${attempt + 1} failed: ${err.message}`);
      await sleep(5000 + Math.random() * 10000);
    }
  }
  return null;
}

Tecniche avanzate

Randomizzazione delle query

Non raschiare parole chiave in ordine alfabetico o sequenziale. Sfrutta la tua lista delle parole chiave prima di ogni esecuzione:

import random
keywords = ["proxy service", "web scraping", "serp tracking", "seo tools"]
random.shuffle(keywords)
# Now scrape in random order
for kw in keywords:
    scrape_with_retry(kw)

Google Search Parametri

Utilizzare questi parametri per ottenere risultati puliti, non personalizzati:

Distribuito Scheduling

Per il monitoraggio SERP su larga scala, distribuire richieste nel tempo per evitare i modelli di scoppio. Invece di raschiare 10.000 parole chiave in un'ora, diffonderle in 8-12 ore con curve di traffico naturali (più richieste durante le ore di lavoro, meno di notte).

L'obiettivo non è solo quello di evitare blocchi — è quello di rendere il vostro rottame traffico indistinguibile dal normale comportamento di ricerca dell'utente. Ogni dettaglio conta.

Per ulteriori informazioni sulla costruzione di tubi di raschiamento affidabili su larga scala, vedere il nostro guida completa ai proxy di raschiamento web e Soluzioni di raschiamento web ProxyHat.