Colly-review: statische HTML, directe JSON en de grens met de browser

Ik heb een fixturesite opgezet om precies dat deel van Colly te testen waar een paginatelling of snelheidsverhaal niks over zegt: of de callbacks de verwachte records ophalen, een HTTP-fout netjes afhandelen, een begrensde grafiek volgen en content zichtbaar maken die buiten de gerenderde HTML wordt aangeleverd. Dit was een controle- en randgevallenreview, geen throughputbenchmark.

Op de gecontroleerde fixtures haalde het alle verwachte statische records op, stuurde het één 500-respons door naar OnError en bezocht het 17 URL’s in de geconfigureerde depth-limited grafiek. Het gaf nul target-elementen terug op twee pagina’s waarvan de elementen pas na JavaScript-uitvoering verschenen. Een rechtstreeks bereikbaar JSON-endpoint bleef bruikbaar zonder browser; dat is een belangrijk verschil met het renderen van de client-UI.

Wat Colly precies is

Colly noemt zichzelf een “elegant scraper and crawler framework for Golang”, en die omschrijving dekt meer dan je op het eerste gezicht zou denken. Het is een Go-library — met ongeveer 25.300 GitHub-stars en 1.850 forks — onder Apache-2.0. Het is geen CLI die je downloadt en op een URL richt. Je schrijft Go-code, importeert Colly, registreert een paar callbacks en compileert alles tot één executable.

Het mentale model is event-driven. Je koppelt handlers aan een Collector: OnHTML voert extractielogica uit voor matchende CSS-selectors, OnResponse geeft de ruwe responsebody door, en OnError handelt requestfouten af. Link-handlers roepen Visit() aan op ontdekte URL’s, terwijl MaxDepth de traversie begrenst. Voor deze HTTP-only paden is op de doelhost geen apart geïnstalleerde Go-runtime of browser nodig; of de executable volledig statisch is, hangt af van build flags en CGO-gebruik, en dat heb ik in deze test niet vastgelegd.

Belangrijkste functies, en hoe ze onder de motorkap werken

Het callbackmodel is het belangrijkste om te begrijpen, omdat Colly daardoor anders aanvoelt dan een script dat simpelweg ophaalt en parseert. Drie callbacks droegen elke test die ik uitvoerde.

OnHTML(selector, handler) is het werkpaard. Koppel het aan .product of article p en Colly roept je handler één keer per gematcht element aan terwijl het de DOM verwerkt. Hier zit gestructureerde extractie; het leest lekker weg — je beschrijft wat je wilt ophalen, in plaats van een parse-lus te schrijven.

OnResponse(handler) zit een niveau lager en geeft je de ruwe bytes. Als een target JSON terugstuurt in plaats van HTML, sla je de DOM volledig over en parse je de body zelf. Die ene callback is waarom Colly in mijn test netjes met een JSON-API omging zonder ook maar enige HTML-parsing.

OnError(handler) handelt requestfouten af en kan een response-status aan de aanroepende code tonen. In deze test bereikte één fixture-respons met status 500 de geregistreerde callback. Retries, time-outs, DNS-fouten, connection resets, callback-panics, persistentie en alerting zijn niet getest.

Bovenop de callbacks zitten twee operationele functies. MaxDepth begrenst linktraversie volgens Colly’s depth-semantiek. Een gecompileerde Go-executable vermijdt bovendien een apart geïnstalleerde taal-runtime op de doelhost. Deze run legde build flags of CGO-status niet vast, dus er wordt niet beweerd dat elke resulterende binary volledig statisch is.

Setup: de vereiste Go-toolchain

Het afhankelijkheidsverhaal is kort maar reëel, dus hier staat het voordat je iets installeert. De machine waarop ik testte had geen Go geïnstalleerd, en Colly is een Go-library — dus stap nul was een Go-toolchain op het systeem zetten (ik installeerde Go 1.26.5 via Homebrew). Als je team niet al in Go werkt, zit daar de frictie: niet in Colly zelf, maar in de taalomgeving die nodig is voordat ook maar één regel compileert.

Zodra Go er was, wees go get github.com/gocolly/colly/v2 naar v2.3.0. Voor de geteste paden was geen browser of headless Chrome nodig.

Eén versieverschil kan lezers in verwarring brengen. De Go-module loste op naar v2.3.0 (gepubliceerd in december 2025), terwijl de nieuwste zichtbare entry in GitHub’s Releases-UI v2.2.0 (maart 2025) was toen ik keek. Dat verschil gaat over module-/repositoryversie versus GitHub Release-entry, niet over module versus Git-tag. Ik heb v2.3.0 getest.

Praktijk: extractie en operationele grenzen

Ik liet Colly draaien tegen een zelfvoorzienende fixtureserver (Go’s httptest) plus twee publieke demowebsites. De huidige benchmarkdirectory en results/colly-test-summary.json tonen artefacten, maar beide links volgen een bewegende branch. Het artikel geeft geen getest commit, exact commando, build flags of fixture seed, dus dit is nog geen onveranderlijke reproductie-instructie.

Op de gecontroleerde statische fixtures leverden de ingestelde selectors 12 van de 12 verwachte productrecords op en alle drie verwachte artikelparagrafen. De directe JSON-respons raakte nooit een HTML-parser: OnResponse leverde de body aan en de harness decodeerde alle acht verwachte items. De ene 500-fixture bereikte OnError met zichtbare status en crashte die run niet; dat zegt nog niets over betrouwbare unattended werking. Op de publieke Books to Scrape -pagina gaf de selector 20 producten terug als publieke smoke test.

Voor traversie werd de collector geconfigureerd met MaxDepth(2) volgens de seed-depth-conventie van de harness en bezocht hij 17 URL’s in de fixturegrafiek. Het resultaat gaat over crawldekking, niet over snelheid. De waargenomen trace — en geen bredere claim over willekeurige grafieken — staat in results/local_crawl_graph.json.

Colly voert geen JavaScript uit. De fixture met JavaScript-rendering leverde 0 target-kaarten op, en de publieke Quotes to Scrape JS-pagina leverde 0 target-quotes op. Als elementen pas bestaan na browseruitvoering en er geen toegankelijk backing-endpoint is dat ze aanlevert, kan de HTTP-only route die elementen niet als gerenderde DOM zien. Combineer het met een renderer, of roep het backing-endpoint rechtstreeks aan wanneer dat beschikbaar is, zoals de JSON-fixture laat zien.

Ik heb de async collector, rate limiting of politeness-configuratie, proxy-rotatie, retries of queue- en storage-backends niet belast. Er zijn geen elapsed time, throughput, concurrency, CPU, memory, target latency of vergelijkingsbaseline gemeten. Dit artikel doet dus geen claim over snelheid of unattended betrouwbaarheid.

Hoe je de fixture-resultaten moet interpreteren

De drie geslaagde contentpaden toetsen verschillende contracten. De catalogus- en artikelgevallen testen CSS-selectie op HTML die de server terugstuurt. Hun noemers zijn fixtureverwachtingen die vóór de extractie zijn vastgelegd: twaalf productrecords en drie artikelparagrafen. Dat als “verwachte records geëxtraheerd” rapporteren is bewust. De run definieert geen fuzzy matching, duplicate handling, tolerantie voor gedeeltelijke velden of een corpusbrede recall-metriek, dus je moet dit resultaat niet verheffen tot algemene extractie-accuratesse.

Het JSON-geval omzeilt DOM-selectie. Colly ontvangt de responsebytes via OnResponse, en de harness doet de JSON-decoding. Daarom betekent “Colly voert geen JavaScript uit” niet dat elke site met client-side logica onbereikbaar is. Als de databron die de client gebruikt een rechtstreeks aanroepbaar endpoint is en de request buiten de browser reproduceerbaar is, kan de HTTP-crawler nog steeds voldoende zijn. Authenticatie, gegenereerde signatures, browser-only state en anti-botmaatregelen kunnen dat antwoord veranderen; hier is niets van dat alles getest.

De 500-route test dispatch, niet recovery. Het laat zien dat de geregistreerde OnError-callback die fixture-respons en de status daarvan ontving. Een productiecrawler heeft nog steeds een expliciet beleid nodig voor retryable codes, backoff, terminal failures, persistence en alerting. De test levert geen bewijs voor die keuzes, en “de callback ging af” mag niet gelezen worden als “de job kan zonder toezicht vertrouwd worden”.

De grafiek met 17 URL’s is net zo begrensd. Hij bevestigt de set bezochte pagina’s die door deze fixture, deze seed-conventie en MaxDepth(2) werd geproduceerd. Hij zegt niets over pagina’s per seconde, eerlijkheid tussen hosts, geheugengroei of gedrag bij cycles en dubbele URL-vormen. Daarvoor zijn aparte workload- en queue-tests nodig.

Een selectiechecklist gebaseerd op deze run

Begin met kijken naar de response die Colly daadwerkelijk ontvangt. Als de vereiste velden in HTML van de server aanwezig zijn, gebruik dan OnHTML en valideer veldaantallen of verplichte keys voordat je een record accepteert. Als de response JSON is, handel de body af via OnResponse en valideer het schema. Als de HTML slechts een applicatieshell is, onderzoek dan of een toegankelijk backing-request de data bevat voordat je een browser toevoegt.

Wanneer browseruitvoering noodzakelijk is, behandel die dan als een aparte component in plaats van te verwachten dat een Colly-flag rendering inschakelt. De browser moet readiness vaststellen, de gerenderde content of backing-responses blootleggen en data doorgeven aan de rest van de pipeline. Deze review heeft zo’n integratie niet getest.

Leg voor deployment de Go-versie, moduleversie, build flags, CGO-status, exact commando, fixture seed en repository-commit vast. Die details ontbreken in de huidige publicatielinks en vormen het verschil tussen inspecteerbare artefacten en duurzame reproductie. Voeg voor operations een failure matrix toe en meet de workload die je echt belangrijk vindt voordat je het systeem snel of betrouwbaar noemt.

Voor- en nadelen

Voordelen:

• Extrapoleerde 12/12 verwachte catalogusproducten en 3/3 verwachte artikelparagrafen via OnHTML.
• Nette JSON-afhandeling via OnResponse, geen DOM-parsing nodig — 8/8 API-items.
• De geteste 500-respons bereikte OnError met zichtbare status.
• Depth-limited crawl bereikte 17 pagina’s vanuit één collector.
• Compileert naar een Go-executable; voor de geteste paden is op de doelhost geen apart geïnstalleerde Go-runtime nodig.
• Permissieve Apache-2.0-licentie.

Nadelen:

• Geen JavaScript-uitvoering — client-gerenderde content levert 0 op, punt uit.
• Vereist een Go-toolchain; teams die niet in Go werken betalen die setupkosten voordat ze ook maar één scraper schrijven.
• De geteste module (v2.3.0) loopt vooruit op de nieuwste waargenomen GitHub Release-entry (v2.2.0).
• Output is je eigen code — Colly geeft je callbacks, geen ingebouwde dataset/feed-exporter zoals Scrapy.
• Async, rate limiting, proxy- en queue-backends bestaan, maar zijn hier niet getest; throughput en schaal blijven ongemeten.

Voor wie het bedoeld is — en wie het beter kan overslaan

Colly past goed als je al Go schrijft en server-gerenderde HTML of direct toegankelijke JSON target. Het callbackmodel scheidt gestructureerde matches, ruwe payloads en requestfouten. Een gecompileerde executable vermijdt bovendien een apart geïnstalleerde taalomgeving op de doelmachine, al is volledig statische linking hier niet geverifieerd.

Voeg een renderer toe wanneer vereiste target-elementen pas na browseruitvoering verschijnen en er geen bruikbaar backing-endpoint bestaat. Een direct JSON-endpoint kan nog steeds zonder rendering worden opgevraagd. Colly past ook minder goed bij teams die geen Go-toolchain willen, of die willen dat een extractieservice schema-opmaak en onderhoud van selectors overneemt.

Alternatieven, inclusief waar Thunderbit past

Colly is open-source software die je zelf draait. Er zijn geen licentiekosten aan de vendorzijde, maar compute, bandwidth, proxies, storage, observability en engineering blijven jouw kosten. Je beheert requestgedrag, parsing-callbacks, crawl-logica en browserintegratie als een target rendering nodig heeft.

Een managed extraction service verplaatst een deel van die verantwoordelijkheden naar een leverancier. Wij bouwen Thunderbit, maar hebben het niet tegen deze fixtures getest, dus dit artikel maakt geen vergelijking op het gebied van rendering, anti-bot, kwaliteit, latency of kosten. Het ondersteunde onderscheid is eigenaarschap: Colly geeft HTTP-responses en callbacks bloot in je Go-proces; een managed service kan acquisitie en schema-opmaak voor een fee per call beheren.

Gerelateerde benchmarkreviews: de volledige vergelijking van open-source scrapers, de Python-crawlerreview van Scrapy en de adaptive-selectorreview van Scrapling.

Probeer Thunderbit voor webdata-extractie

Eindoordeel

Colly is een sterke kandidaat voor Go-teams die server-gerenderde HTML of directe JSON targetten en bereid zijn hun eigen extractiecode te onderhouden. De fixtures ondersteunen extractie van verwachte records, één begrensde crawltrace en één waargenomen 500-callback — niet snelheid, schaal of unattended betrouwbaarheid. Browser-gerenderde DOM vereist een andere route, tenzij het onderliggende data-endpoint rechtstreeks kan worden aangeroepen.

Probeer Thunderbit voor webdata-extractie Get Started Free

FAQ’s

Heeft deze review de snelheid van Colly gemeten? Nee. Er is gekeken naar extractie van verwachte records, directe JSON-afhandeling, één error-callback en de dekking van een fixture-crawlgrafiek. Elapsed time, throughput, concurrency, CPU, memory of een vergelijkingsbaseline zijn niet gemeten.

Kan Colly JavaScript-gerenderde pagina’s scrapen? Colly voert de JavaScript van de pagina niet uit. De geteste HTTP-route vond daarom geen target-elementen die alleen in de gerenderde DOM verschenen. Het kan wel rechtstreeks een toegankelijk backing-JSON-endpoint opvragen, zoals de JSON-fixture laat zien. Gebruik een renderer wanneer uitvoering vereist is en geen reproduceerbare backing-request de data levert.

Moet ik Go kennen om Colly te gebruiken? Ja. Colly is een Go-library, geen standalone CLI — je importeert hem, registreert callbacks (OnHTML, OnResponse, OnError) en compileert. De machine waarop ik testte had geen Go, dus de setup begon met het installeren van een Go-toolchain (1.26.5). Als je team niet al in Go werkt, is die omgeving de echte setupkost.

Waarom komt de versie die ik installeer niet overeen met de nieuwste GitHub-release van Colly? De Go-module loste op naar v2.3.0 (december 2025), terwijl de nieuwste waargenomen GitHub Release-entry v2.2.0 (maart 2025) was. Ik heb v2.3.0 getest; dit is een verschil tussen versiebronnen, geen bewijs van een kapotte installatie.

Is Colly gratis voor commercieel gebruik? Het gebruikt Apache-2.0, wat permissief is en commercieel vriendelijk. Controleer zoals altijd de actuele licentie in de repo voordat je erop voortbouwt.

Voordat je het in productie inzet, voeg tests toe die aansluiten op het werkelijke operationele risico in plaats van het fixture-resultaat simpelweg door te trekken. Meet herhaalde crawls op representatieve targets, registreer CPU en piekgeheugen, test retryable en terminal failures, en verifieer politeness onder concurrency. Als persistentie belangrijk is, stop en hervat dan een crawl terwijl je duplicate handling en queue-state inspecteert. Als deployment-simpliciteit belangrijk is, leg dan de exacte compiler- en linkerconfiguratie vast en inspecteer de runtime-afhankelijkheden van de geproduceerde executable. Geen van die controles verandert wat de huidige fixture heeft vastgesteld; ze bepalen alleen of dezelfde libraryconfiguratie past bij een specifieke productieklus.