Een webscraper verzamelt niet alleen pagina’s: hij moet de juiste URL’s vinden, veranderende HTML verwerken en gegevens opslaan die controleerbaar blijven. In dit artikel lees je hoe crawling, parsing, toegangsregels en datakwaliteit samenkomen in een scraper die in de praktijk te onderhouden is. Voor maatwerk kun je een freelance developer inschakelen.
URL-selectie bepaalt welke gegevens een scraper verzamelt
Je begint altijd met het vastleggen van welke pagina’s en gegevens relevant zijn. Makkelijk lijkt dat niet: een site kan duizenden URL’s bieden. Denk aan filters, sorteringen, taalinstellingen en trackingcodes. Ga je zonder criteria crawlen, dan zie je vaak dubbele inhoud of sla je nuttige detailpagina’s over. Bepaal dus specifiek welke domeinen, paden of paginatypes binnen je scope vallen en leg ook vast waar een bruikbare pagina aan moet voldoen.
URL’s haal je bijvoorbeeld uit een sitemap (als die actueel is), een startpagina, een categoriepagina of een bestaande lijst. Gebruik je een sitemap, dan heb je snel een lijst, maar het zegt niet altijd iets over de inhoud. Categoriepagina’s volgen kan waardevolle relaties opleveren, maar je eindresultaat hangt sterk af van de menustructuur. Meestal meng je bronnen en normaliseer je gevonden URL’s nog vóór ze daadwerkelijk worden bezocht.
Normaliseren? Dat is bijvoorbeeld hekje-fragmenten eruit gooien, parameters sorteren of standaard onzinnige trackingparameters negeren. Let wel: soms geeft een parameter aan om welke productvariant of op welke pagina je zit (dus niet zomaar alles strippen). Houd per pagina bij waarom die is toegelaten of juist niet, zodat je later snapt waarom iets ontbreekt en voorkomt dat technische keuzes stilzwijgend je dataset bepalen.
Paginering en crawlvolgorde vragen om expliciete regels
Paginering is everywhere: productoverzichten staan bijna nooit op één pagina. Soms zie je een ?page=2 in de URL, soms een "meer laden"-knop die met JavaScript werkt, of een onzichtbare cursorwaarde. Jij moet bepalen hoe je ontdekt óf en waar zo’n collectie stopt. Vertrouw niet blind op een oplopend paginanummer; sommige sites leveren een lege laatste pagina, slaan nummers over of veranderen halverwege de sortering (dat is vragen om ellende).
Is het gewone paginering via HTML? Volg dan de "volgende" link en check of die niet al bezocht is. Cursor? Dan moet je de waarde uit de vorige respons halen en goed overnemen in het nieuwe verzoek. Zet altijd limieten op het aantal pagina’s en het aantal keren dat je een URL opnieuw ziet. Die voorkomen dat de boel in een lus blijft hangen omdat een pagina je steeds dezelfde link toestuurt of er een fout in de structuur zit.
Hoe je crawlt, maakt uit voor volledigheid en impact op de site. Breedte-eerst verzamelt links op hetzelfde niveau; diepte-eerst volgt alles zo ver mogelijk uit. In een productcatalogus is het vaak handig om per categorie apart te crawlen en die voortgang vast te leggen. Bewaar bezochte URL’s en resultaten, zo kun je bij een storing makkelijk het juiste deel opnieuw ophalen. Dat scheelt flink werk als je maar een klein segment mist.
Robots.txt en toegangsbeperkingen horen bij het crawlontwerp
Robots.txt vind je op het hoofddomein en dat bestand beschrijft gericht welke plekken een crawler wel of niet mag bezoeken volgens de opgegeven regels. Je scraper moet dit bestand checken en alleen de regels toepassen die relevant zijn voor de opgegeven user-agent. Robots.txt is géén slot op de deur, geeft dus niet automatisch toestemming om gegevens te gebruiken, en zegt alleen iets over de voorkeur van de site. Kijk sowieso naar de gebruikersvoorwaarden en het soort gegevens dat je ophaalt; zeker als je met persoonsgegevens of beschermde info aan de slag gaat.
Toegangsblokkades zie je soms direct in een HTTP-foutcode, een CAPTCHA, loginpagina of een blokkade na veel verzoeken. Neem dat serieus: niet gewoon omzeilen, maar pauzeren of aanpak heroverwegen. Een scraper die met proxies, wisselende identificatie of nep-browsers probeert te glippen, werkt vaak onbetrouwbaar en wordt meestal niet gewenst. Bouw checks in voor 401, 403 en 429: leg vast wanneer deze voorkomen en wat daarmee gebeurt.
Crawlers die beheerst werken letten goed op de belasting. Doe niet te veel gelijktijdige verzoeken, bouw wachttijd in, cache wat je al hebt. Houd je aan limieten, stop bij een duidelijke hint vanaf de server. Zo blijft het betrouwbaar, ook als een website het druk heeft of het beleid ondertussen verandert.
HTTP-responsen en retries vormen de basis van betrouwbaar crawlen
Vaak denk je bij een HTTP-verzoek vooral aan de HTML, maar er komt meer bij kijken. Je krijgt een statuscode, headers, verwijzingen en soms een redirect of trage respons. Zelfs bij een 200-status is het geen garantie dat je de juiste content hebt; er kan een foutmelding achter zitten, een lege opzet of een verplicht loginvenster. Kijk dus niet alleen naar de code, maar check kenmerken van de inhoud zelf en bewaar relevante context bij de body.
Afwijkingen kun je niet overal hetzelfde behandeln. Tijdelijke problemen op de server? Wacht even en probeer het later nog eens. 404- of andere structurele fouten? Die los je niet op door direct nogmaals te proberen. 429 betekent echt dat vertragen belangrijk is. Doe een beperkt aantal retries, laat de wachttijden oplopen, en voorkom dat je met meerdere pogingen tegelijk op dezelfde mislukte link blijft schieten. Dat maakt het probleem alleen groter.
Redirects zijn een apart verhaal. Soms normaal (bijvoorbeeld www-varianten worden omgeleid), soms onverwacht richting bijvoorbeeld een loginpagina of een errorpagina. Leg altijd vast welke URL je bedoelde en waar je echt uitkwam. Zet er een limiet op, zodat je niet eindeloos doorverwijst. Time-outs kun je indelen in verbindingsproblemen of trage servers; handig om te weten bij storingzoeken. Houd gestructureerd bij wat je ophaalt: URL, statuscode, laadtijd, type fout. Zonder die info is een mislukte crawl vaak niet te onderscheiden van een ontbrekende bronpagina.
HTML-parsing zet pagina-elementen om in gestructureerde velden
Met HTML-parsing zet je de ruwe pagina om naar velden die je echt wilt hebben: denk aan titel, prijs, datum, kenmerken. Begin niet alleen met één voorbeeld, maar check liever verschillende plekken op de site. Een selector die werkt op een productpagina, kan de mist in gaan bij een overzicht, een variant, of een oudere pagina. CSS-selectors of XPath zijn handig om elementen te vinden; kies vooral een selector die past bij het element zelf en niet bij een toevalslocatie in de DOM.
Gebruik preferente selectors op namen, stabiele attributen, semantische tags of logische parent-child relaties. Selectors gebaseerd op ‘derde element in regel’ zijn kwetsbaar: voeg iemand een label toe en alles schuift door. Probeer zoveel mogelijk uit de context te halen en check hoeveel elementen je selectie oplevert. Moet je precies één waarde hebben? Dan is géén óf meer dan één match een signaal om te waarschuwen, niet om gewoon maar wat te nemen.
Na selecteren volgt normaliseren. Decodeer HTML-entiteiten, haal overbodige witruimte weg en maak formaten gelijk, zoals data naar dezelfde tijdzone of prijzen zonder valutateken. Soms wil je de ruwe tekst én de opgeschoonde waarde bewaren, zeker bij belangrijke data. Zo kun je later conversiefouten terugleiden naar de bron als dat nodig is. Vergeet niet: veld afwezig is iets anders dan leeg of nul.
Veranderende paginaopbouw vraagt om detectie en herstelbare parsing
Pagina’s veranderen vlot. Nieuwe classnamen, extra velden, oude blokken vervangen, soms lijkt de site hetzelfde, maar de HTML-structuur gooit je scraper helemaal overhoop. Heb je parsing alleen op één vaste selector gebaseerd, dan kan je scraper ineens lege waarden vasthouden zonder dat het proces stopt. Zet daarom checks op structuurwijzigingen al ín je parser, niet pas bij storingsherstel.
Stel verwachtingen vast per paginatype, een productdetailpagina moet altijd een titel en een unieke ID hebben bijvoorbeeld. Check het aantal matches, leegtes, opvallende schuivers in het waardenpatroon per veld. Zie je plots weinig datums, kan dat aan een selector liggen (of gewoon aan gewijzigd aanbod). Bewaar voorbeelden van foutgevallen en een relevant stukje HTML: dat maakt het makkelijker om afwijkingen te onderzoeken zonder de hele crawl opnieuw te moeten doen.
Je parser mag meerdere varianten ondersteunen (handig als een nieuwe en oude paginatype naast elkaar bestaan), maar breed vangen levert sneller foute matches. Maak altijd duidelijk welke parsingvariant je gebruikt hebt en laat onbekende structuren gewoon falen in plaats van onjuiste records te vullen. Liever een duidelijke fout dan een plausibel ogend maar incorrect record. Gebruik versiebeheer voor parserregels en test met opgeslagen pagina’s; zo kun je aanpassingen nuchter volgen en vermijd je regressies. Voor maatwerk in PHP kun je een PHP developer inschakelen.
Datakwaliteit controleer je met validatie en bronvergelijking
Alles technisch in orde en toch waardeloze data? Heel goed mogelijk. Controle op datakwaliteit draait om compleetheid, geldigheid, consistentie en actualiteit. Als eerste check je of verplichte velden gevuld zijn en of waarden passen bij wat je verwacht: een datum moet tot een datum te parsen zijn en niet in een vreemde tijd springen, een product-ID moet ingevuld zijn, een URL moet naar een door jou bedoelde pagina wijzen.
Daarna kijk je naar relaties: een einddatum vóór begindatum kan vaak niet. Een optelsom die niet uitkomt of objecten die aan twee verschillende IDs hangen zijn signalen dat er iets misloopt. Bedenk dat controles moeten passen bij inhoud: een controle op een positief getal sluit negatieve waarden uit die bij bijvoorbeeld een temperatuur gewoon horen.
Vergelijk je verzameling tussen runs en met de bron zelf. Zie je een verdubbeling van records, dan kan daar een aangepaste URL-regel achter zitten; zie je minder ingevulde velden, dan kan een selector het probleem zijn. Met steekproeven naast de bron vind je fouten die automatische controles missen. Registreer niet alleen het totaal verwerkte, maar ook aantallen succesvol, afgekeurd of ongebruikt, dan zie je of een ogenschijnlijk volle dataset stiekem maar een klein deel van de bron dekt.
Opslag, deduplicatie en monitoring maken crawls beheersbaar
Met de opslag leg je vast hoe je later data terugvindt, vergelijkt of opnieuw verwerkt. Gebruik waar mogelijk een stabiele sleutel, een bron-ID of een goed genormaliseerde URL. Let er wel op: een URL is niet altijd uniek voor een object. Die kunnen wijzigen, of verschillende URL’s kunnen op exact dezelfde inhoud uitkomen. Leg daarom altijd bron-ID én URL vast en documenteer de gekozen deduplicatieregel.
Bewaak naast de actuele data ook het moment en de bronpagina waarop ze zijn verzameld. Soms heb je een geschiedenis nodig van wijzigingen, bijvoorbeeld wanneer velden in de tijd veranderen. Ruwe HTML bijhouden is waardevol voor het oplossen van parse-issues, maar kost meer opslag en vraagt om afgewogen keuzes voor bewaartermijn en bescherming. Houd bronresponses gescheiden van de genormaliseerde records, zodat je bij aanpassing van parserregels niet alles kwijt bent.
Maak monitoring concreet: alleen weten dat een proces start en stopt is niet genoeg. Volg hoeveel URL’s je bezoekt, welke statuscodes je krijgt, foutmeldingen bij parsing, leegtes in belangrijke velden, én hoeveel nieuwe of dubbele records verschijnen. Stuur pas signalen bij afwijkingen die samen écht iets zeggen: minder pagina’s kan wijzen op een seizoen of een kapotte crawler. Bouw herverwerking in per URL of batch en voorkom dat dezelfde run dubbel wordt opgeslagen. Daarmee kun je reconstructies doen als bron, parser of configuratie veranderen. Wil je dit soort processen verder stroomlijnen? Bekijk automatisering met API-koppelingen. Zie ook betrouwbare automatisering met logging en foutafhandeling.
Veelgestelde vragen
Hoe scrape je een website die inhoud via JavaScript laadt?
Begin met zoeken naar een HTTP-verzoek dat de gegevens rechtstreeks levert. Gebruik je browser om te kijken welke network-calls de pagina doet. Zit de informatie daarin en mag je die volgens de voorwaarden gebruiken? Pak dan die route. Is de inhoud alleen na uitvoeren van JavaScript beschikbaar, dan kun je een headless browser gebruiken om de pagina te laden en daarna de gerenderde data te lezen. Dat kost meer tijd en machinekracht, dus gebruik browserautomatisering alleen waar het echt niet anders kan.
- Kijk of er een openbare API of datastroom is.
- Bewaak en test met opgeslagen pagina’s of de dynamische inhoud verandert.
Wanneer kun je beter een API gebruiken dan een webscraper?
Voorkeur gaat uit naar een API als die de gewenste data volgens de regels beschikbaar stelt. Zo’n API biedt meestal netjes gestructureerde velden; dat maakt minder afhankelijk van HTML-wijzigingen. Controleer wel altijd zelf of het aanbod, de actualiteit en de rechten volgens plan zijn; alleen omdat een endpoint publiek lijkt, wil niet zeggen dat elk gebruik klopt. Mist een API bepaalde data of heb je andere eisen, kun je alsnog kiezen voor scraping, vooropgesteld dat de regels van de website het toestaan.
- Vergelijk welke velden en pagina’s per bron beschikbaar zijn.
- Let op authenticatie, restricties per gebruiker, versiewijzigingen en toegestane toepassingen.
Hoe test je een webscraper voordat je die op grote schaal uitvoert?
Test altijd eerst met een kleine, representatieve set pagina’s, liefst met varianten, ontbrekende velden en structurere verschillen. Controleer handmatig of de resultaten kloppen voordat je grootschalig draait. Bouw daarna automatische checks op velden, datatypen en relaties, en voer die bij elke wijziging uit. Vergeet niet te testen wat er gebeurt bij fouten, time-outs of rare HTTP-statussen: je wilt weten hoe je scraper reageert, niet alleen bij succes.
- Sla voorbeeldpagina’s op als vaste testbasis.
- Check of geëxtraheerde waarden en foutmeldingen overeenkomen met de bron.
Hoe vaak moet je een webscraper opnieuw laten draaien?
Draai alleen zo vaak als nodig is voor de gewenste actualiteit, niet vaker. De passende frequentie hangt af van hoe snel de bron echt verandert en hoe actueel de data moeten zijn voor jouw doel. Een voorraad die dagelijks wijzigt kun je vaker ophalen dan een zeldzaam geüpdatete catalogus. Begin liever te bescheiden dan te enthousiast, meet hoe snel data wijzigen en pas het schema aan. Denk aan belasting voor de site en aan toegangsregels.
- Leg per soort data vast hoe actueel het echt moet zijn.
- Download een pagina niet nodeloos opnieuw als er niks is veranderd.
Welke programmeertaal is geschikt om een webscraper te bouwen?
Python is gangbaar voor veel scrapers, maar kies altijd een taal die aansluit bij jouw team, infrastructuur en eisen. Python heeft veel libraries voor HTTP, HTML-parsing en testen. JavaScript is handig als je bestaande webtechnieken wil inzetten of browserautomatisering nodig hebt. Maar factoren als onderhoudbaarheid, beschikbare kennis, schaalbaarheid en aansluiting bij bestaande systemen zijn minstens zo belangrijk. Probeer elke aanpak eerst op een kleine set pagina’s voordat je verder bouwt.
- Let bij keuze tooling goed op de soorten paginastructuren die je gaat verwerken.
- Kijk niet alleen naar ontwikkeltijd, maar ook naar testen, logging en doorontwikkeling.
Foto: Pixabay