AI-agenten · Les

Respectvol scrapen

Voldoen aan robots.txt, user-agent-headers gebruiken, verzoeken vertragen en caching toepassen.

Les 4 van 413 stappen

Respectvol scrapen is een gratis AI-agenten-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject AI-agenten. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus AI-agenten bevat in totaal 4 lessen.

Waarom respectvol scrapen belangrijk is

Webscraping kan servers zwaar belasten, servicevoorwaarden schenden en ervoor zorgen dat het IP-adres van je agent wordt geblokkeerd. Verantwoord scrapen houdt rekening met snelheidslimieten, maakt duidelijk wie de verzoeken verstuurt en respecteert de regels die websites publiceren.

In deze les leer je hulpmiddelen en technieken om ethisch en duurzaam te scrapen.

robots.txt controleren

Elke website kan een robots.txt-bestand publiceren waarin staat tot welke paden geautomatiseerde agents wel of geen toegang hebben. De standaardbibliotheek van Python bevat urllib.robotparser om dit bestand te parseren.

Controleer altijd robots.txt voordat je een website scrapt.

import urllib.robotparser

rp = urllib.robotparser.RobotFileParser()
rp.set_url('https://example.com/robots.txt')
rp.read()

# Check if our bot can fetch a specific path
can_fetch = rp.can_fetch('MyAgent/1.0', 'https://example.com/public-data')
print(f'Can fetch: {can_fetch}')  # True or False

cannot_fetch = rp.can_fetch('*', 'https://example.com/private/admin')
print(f'Admin allowed: {cannot_fetch}')  # Often False

Een beschrijvende User-Agent instellen

De HTTP-header User-Agent geeft aan wie een verzoek verstuurt. Met een eerlijke User-Agent weten websitebeheerders wat je bot is en hoe ze contact met je kunnen opnemen als er problemen zijn. Je voordoen als een browser om blokkades te omzeilen roept ethische bezwaren op.

import httpx

headers = {
    # Honest, descriptive User-Agent
    'User-Agent': 'MyResearchBot/1.0 (contact: me@example.com; purpose: academic research)'
}

response = httpx.get(
    'https://example.com/data',
    headers=headers,
    timeout=10.0
)

print(response.status_code)

Snelheidslimieten met time.sleep()

Honderden verzoeken per seconde versturen kan een server overbelasten en wordt vaak behandeld als een denial-of-serviceaanval. Voeg met time.sleep() vertragingen tussen verzoeken toe. Gebruik random.uniform() om de vertraging minder robotachtig en menselijker te maken.

import time
import random
import httpx

urls = [
    'https://example.com/page/1',
    'https://example.com/page/2',
    'https://example.com/page/3'
]

for url in urls:
    response = httpx.get(url, timeout=10.0)
    print(f'Fetched {url}: {response.status_code}')

    # Wait between 1 and 3 seconds before the next request
    delay = random.uniform(1, 3)
    print(f'Sleeping {delay:.1f}s...')
    time.sleep(delay)

Retry-After-headers respecteren

Wanneer een server reageert met 429 Too Many Requests, bevat de reactie vaak een Retry-After-header die aangeeft hoeveel seconden je moet wachten. Je agent moet deze waarde uitlezen en respecteren in plaats van meteen opnieuw een verzoek te versturen.

import time
import httpx

def fetch_with_retry(url: str) -> httpx.Response:
    while True:
        response = httpx.get(url, timeout=10.0)

        if response.status_code == 429:
            retry_after = int(response.headers.get('Retry-After', 5))
            print(f'Rate limited. Waiting {retry_after}s...')
            time.sleep(retry_after)
            continue  # retry

        response.raise_for_status()
        return response

Reacties cachen om herhaalde downloads te voorkomen

requests-cache slaat HTTP-reacties automatisch op in een cache op schijf. Als je agent dezelfde URL meerdere keren moet ophalen, bijvoorbeeld tijdens de ontwikkeling of bij nieuwe uitvoeringen, worden de reacties direct uit de cache teruggegeven zonder de server opnieuw te benaderen.

# pip install requests-cache
import requests_cache

# Install the cache globally — cached responses expire after 1 hour
requests_cache.install_cache(
    'agent_cache',
    backend='sqlite',
    expire_after=3600  # seconds
)

import requests

# First call: fetches from network and caches
response = requests.get('https://api.example.com/data')
print(response.from_cache)  # False

# Second call: returns cached result instantly
response2 = requests.get('https://api.example.com/data')
print(response2.from_cache)  # True

Handmatig cachen met bestanden en httpx

Als je liever geen requests-cache gebruikt, werkt een eenvoudige cache op basis van bestanden goed. Sla reacties op als JSON-bestanden met een hash van de URL als sleutel en laad ze opnieuw als het bestand nog vers genoeg is.

import hashlib
import json
import os
import time
import httpx

CACHE_DIR = '/tmp/agent_cache'
os.makedirs(CACHE_DIR, exist_ok=True)

def cached_get(url: str, ttl_seconds: int = 3600) -> dict:
    key = hashlib.md5(url.encode()).hexdigest()
    cache_file = os.path.join(CACHE_DIR, key + '.json')

    if os.path.exists(cache_file):
        age = time.time() - os.path.getmtime(cache_file)
        if age < ttl_seconds:
            with open(cache_file) as f:
                return json.load(f)

    response = httpx.get(url, timeout=10.0)
    response.raise_for_status()
    data = response.json()
    with open(cache_file, 'w') as f:
        json.dump(data, f)
    return data

De servicevoorwaarden lezen

Lees de servicevoorwaarden van een website voordat je deze scrapt. Veel websites verbieden geautomatiseerde toegang of commercieel gebruik van hun gegevens uitdrukkelijk. Het schenden van de servicevoorwaarden kan leiden tot juridische stappen, niet alleen tot een geblokkeerd IP-adres.

Als er een officiële API bestaat, geef daar dan altijd de voorkeur aan boven het scrapen van HTML — die is sneller, stabieler en juridisch veiliger.

Exponentieel terugschakelen bij fouten

Wanneer een verzoek mislukt, probeer het dan niet meteen opnieuw. Gebruik exponentieel terugschakelen: wacht eerst 1 seconde, daarna 2 seconden, vervolgens 4 seconden enzovoort. Zo voorkom je dat je een server die al problemen heeft blijft belasten. Dit is een professionele aanpak voor agents in productie.

import time
import httpx

def fetch_with_backoff(url: str, max_retries: int = 4) -> dict:
    for attempt in range(max_retries):
        try:
            response = httpx.get(url, timeout=10.0)
            response.raise_for_status()
            return response.json()
        except (httpx.HTTPStatusError, httpx.RequestError) as e:
            if attempt == max_retries - 1:
                raise
            wait = 2 ** attempt  # 1, 2, 4, 8 seconds
            print(f'Attempt {attempt+1} failed: {e}. Retrying in {wait}s...')
            time.sleep(wait)
    return {}

Alleen scrapen wat je nodig hebt

Beperk de belasting van de server door alleen op te halen wat je agent daadwerkelijk nodig heeft. Download geen volledige pagina's als een klein API-eindpunt dezelfde gegevens teruggeeft. Gebruik HEAD-verzoeken om te controleren of een bron is gewijzigd voordat je de volledige inhoud ophaalt.

import httpx

def has_page_changed(url: str, last_etag: str = None) -> bool:
    headers = {}
    if last_etag:
        headers['If-None-Match'] = last_etag

    response = httpx.head(url, headers=headers, timeout=5.0)

    if response.status_code == 304:  # Not Modified
        return False

    new_etag = response.headers.get('ETag')
    print(f'New ETag: {new_etag}')
    return True

Samenvatting van de regels voor respectvol scrapen

Een korte checklist voordat je agent een website scrapt:

Controleer robots.txt en respecteer regels die toegang verbieden
Stel een eerlijke, beschrijvende User-Agent in
Voeg willekeurige vertragingen tussen verzoeken toe (time.sleep(random.uniform(1,3)))
Respecteer Retry-After-headers bij reacties met status 429
Cache reacties om overbodige downloads te voorkomen
Lees de servicevoorwaarden van de website
Geef de voorkeur aan officiële API's boven HTML-scraping wanneer die beschikbaar zijn

Kennistoets: respectvol scrapen

Test je begrip van ethische en respectvolle werkwijzen voor scrapen.

Beantwoord dit in de interactieve les

Samenvatting: respectvolle werkwijzen voor scrapen

Je beschikt nu over een complete gereedschapskist om verantwoord te scrapen:

robotparser om te controleren waartoe je toegang hebt
Beschrijvende User-Agent-headers die je bot identificeren
time.sleep(random.uniform(1,3)) tussen verzoeken
requests-cache of handmatig cachen om dubbele downloads te voorkomen
Exponentieel terugschakelen voor foutafhandeling
Juridische bewustwording: controleer altijd de servicevoorwaarden

Verantwoord scrapen draagt bij aan een gezonder web en zorgt ervoor dat je agents zonder blokkades blijven werken.

Gratis beginnen

Leer AI-agenten met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 60
Lessen: 239

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Respectvol scrapen” gratis?

Ja — de volledige tekst van “Respectvol scrapen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus AI-agenten wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus AI-agenten bevat in totaal 4 lessen.

Wat leer ik in “Respectvol scrapen”?

Voldoen aan robots.txt, user-agent-headers gebruiken, verzoeken vertragen en caching toepassen. Je oefent met AI-agenten door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met AI-agenten te beginnen?

Ervaring vooraf is niet nodig. AI-agenten op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Respectvol scrapen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over AI-agenten?

Ja. Elke les over AI-agenten bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

HTTP-clients voor agents: httpx en requests
HTML parsen met BeautifulSoup
Paginering en dynamische inhoud verwerken
Respectvol scrapen

← Terug naar AI-agenten