403, 429 en CAPTCHAs: reageer, vermijd niet

Wat zegt elk signaal mijn crawler?

• 429 is het beleefdst: de content is beschikbaar, maar niet op jouw tempo. RFC 6585 definieert het, vaak met een Retry-After header die zegt wanneer je terug mag komen.
• 403 is een weigering van dit verzoek. Dit kan opgelost worden (verkeerd land, ontbrekende headers, te snel) of definitief (de site staat geen geautomatiseerde toegang tot die content toe).
• Een CAPTCHA of challenge-pagina, vaak met status 403 of 503, betekent dat het botbeheer van de site je verkeer betwijfelt. Het is een escalatie: de stap na genegeerde 429's.

Alle drie zijn oplopende signalen. Sites die zien dat hun 429s genegeerd worden, escaleren naar 403s en challenges, en daarna tot langdurige blokkades van hele IP-bereiken, wat elke gebruiker van die bereiken raakt.

Hoe bouw ik een crawler die juist reageert?

Zet de regels in de fetcher, niet in elke spider. Deze stuurt één verzoek tegelijk per host, respecteert robots.txt en de Crawl-delay, wacht op Retry-After, en stopt met vragen aan een host na drie weigeringen op rij. Hij behandelt een 4xx robots.txt als toestemming en een 5xx als een volledige weigering, zoals RFC 9309 voorschrijft.

import time
import urllib.robotparser
from urllib.parse import urlsplit

import requests

PROXY = "http://USERNAME-country-us:[email protected]:7777"
USER_AGENT = "ExampleCrawler/1.0 (+https://example.com/crawler-info)"


class PoliteFetcher:
    """One request at a time per host; robots.txt, Crawl-delay and Retry-After honoured."""

    def __init__(self, min_interval=1.0, max_refusals=3):
        self.min_interval, self.max_refusals = min_interval, max_refusals
        self.http = requests.Session()
        self.http.proxies = {"http": PROXY, "https": PROXY}
        self.http.headers["User-Agent"] = USER_AGENT
        self.robots, self.next_time, self.refusals = {}, {}, {}

    def _robots(self, root):
        if root not in self.robots:
            rp = urllib.robotparser.RobotFileParser(root + "/robots.txt")
            try:
                r = self.http.get(root + "/robots.txt", timeout=(10, 30))
                if r.status_code >= 500:
                    rp.parse(["User-agent: *", "Disallow: /"])  # unreachable: assume disallow
                else:
                    rp.parse(r.text.splitlines() if r.status_code == 200 else [])  # 4xx: allowed
            except requests.RequestException:
                rp.parse(["User-agent: *", "Disallow: /"])
            self.robots[root] = rp
        return self.robots[root]

    def get(self, url):
        scheme, host = urlsplit(url)[:2]
        if self.refusals.get(host, 0) >= self.max_refusals:
            return None  # this host said no: stop asking
        rp = self._robots("%s://%s" % (scheme, host))
        if not rp.can_fetch(USER_AGENT, url):
            return None
        delay = max(self.min_interval, rp.crawl_delay(USER_AGENT) or 0)
        wait = self.next_time.get(host, 0) - time.monotonic()
        if wait > 0:
            time.sleep(wait)
        r = self.http.get(url, timeout=(10, 30))
        pause = delay
        if r.status_code in (429, 503):
            retry_after = r.headers.get("Retry-After", "")
            pause = max(delay, int(retry_after) if retry_after.isdigit() else 60)
        refused = r.status_code in (403, 429) or "captcha" in r.text[:5000].lower()
        self.refusals[host] = self.refusals.get(host, 0) + 1 if refused else 0
        self.next_time[host] = time.monotonic() + pause
        return r


fetcher = PoliteFetcher()
resp = fetcher.get("https://example.com/")
print(resp.status_code if resp is not None else "skipped")

Wat lost een 403 legitiem op?

Meerdere oorzaken van een 403 liggen aan jouw kant en het oplossen hiervan is terecht:

• Het verkeerde land. Veel sites serveren per regio. Richt je op het land met -country-<code>.
• Onvolledige headers. Stuur Accept, Accept-Language en een eerlijke user agent met een contact-URL. Een browserachtige user agent op een gewone HTTP-client is inconsistent en wordt vaak geweigerd.
• Je eigen tempo. Een 403 die begint na N verzoeken is een snelheidsprobleem; vertraag.

Wat geen oplossing is: user agents rouleren om eruit te zien als veel verschillende mensen, browser-vingerafdrukken spoofen of IP's wisselen om een door de site bewust ingestelde blokkade te omzeilen. Als een site hosting-bereiken filtert om geautomatiseerd verkeer buiten te houden, maakt een residentiële proxy dat die toegang niet toegestaan is.

Waarom niet gewoon de CAPTCHAs oplossen?

Omdat een CAPTCHA de site is die je een vraag stelt waarop je verkeerd zou antwoorden. Geautomatiseerd oplossen verandert een beleefde crawler in een tool die is gemaakt om een toegangscontrole te omzeilen, wat je juridische risico verhoogt: de Amerikaanse zaken van 2026 over zoek-scraping, Google tegen SerpApi en Reddit tegen SerpApi en anderen, draaien om de bewering dat gedaagden een anti-bot systeem omzeilden onder de DMCA anti-omzeilingsregel. De rechtbanken hebben de vraag nog niet beslecht, maar het risico is reëel.

CrawlRelay ondersteunt geen CAPTCHA-oplossing of ontduiking van bot-detectie, en het Acceptable Use Policy verbiedt dit via de gateway. Als je data achter een challenge nodig hebt, vraag dan toegang aan bij de site, gebruik de API, of licentieer de data.

Wanneer moet ik de site in plaats daarvan contacteren?

Wanneer je meer nodig hebt dan de standaardinstellingen toestaan. Veel sites bieden een API, een datafeed, een partnerprogramma of gewoon een hogere limiet voor een crawler die zich identificeert en zijn doel uitlegt. Voeg een contact-URL toe in je user agent, houd een pagina bij die jouw crawler beschrijft en uitlegt hoe je jezelf kunt afmelden, en beantwoord misbruikrapporten snel. Een crawler die bereikbaar is, krijgt waarschuwingen vóór blokkades.