SSR, CSR of SSG: hoe je website wordt opgebouwd en waarom Google dat uitmaakt
In dit artikel
Server side rendering betekent dat de server een pagina kant-en-klaar opbouwt op het moment dat iemand hem opvraagt. Bij client side rendering krijgt de browser een bijna lege pagina en bouwt JavaScript de inhoud op, en bij static site generation zijn alle pagina's vooraf gebouwd. Google kan JavaScript uitvoeren, maar doet dat in een tweede ronde, en veel AI-crawlers deden het bij een meting eind 2024 helemaal niet. In de sites die ik maak, staat alle tekst daarom al in de eerste HTML.
Server side rendering, client side rendering en SSG in één beeld
Elke webpagina die je ziet, is ergens in elkaar gezet: op de server of in je browser, vooraf of op het moment zelf. Dat in elkaar zetten heet renderen. Om de vier gangbare manieren uit elkaar te houden, helpt het om aan een lunchroom te denken.
- Static site generation (SSG): de broodjes liggen klaar in de vitrine. Ze zijn 's ochtends gemaakt en je krijgt ze direct mee. Alle pagina's worden vooraf gebouwd; bij een bezoek gaat er alleen een kant-en-klaar HTML-bestand over de lijn.
- Server side rendering (SSR): de kok maakt je broodje als je bestelt. Vers en precies naar wens, maar je wacht even. De server bouwt de pagina bij elk verzoek opnieuw op, vaak met gegevens uit een database.
- Client side rendering (CSR): je krijgt de ingrediënten en een recept, en smeert zelf aan tafel. De server stuurt een bijna lege pagina plus een pakket JavaScript, en de browser van de bezoeker bouwt de inhoud op.
- Incremental static regeneration (ISR): de vitrine, met een medewerker die aanvult. Pagina's zijn vooraf gebouwd, maar worden op de achtergrond vervangen na een ingestelde tijd of na een wijziging. De term komt uit Next.js.
| Waar wordt de pagina gebouwd? | Wanneer? | Wat krijgt de bezoeker eerst? | |
|---|---|---|---|
| SSG | Bij het bouwen van de site | Vooraf, bij elke publicatie | Volledige HTML |
| SSR | Op de webserver | Bij elk verzoek | Volledige HTML |
| CSR | In de browser | Nadat de JavaScript geladen is | Een bijna lege pagina |
| ISR | Op de server | Vooraf, daarna op de achtergrond ververst | Volledige HTML |
Twee dingen vallen op. Bij drie van de vier manieren krijgt de bezoeker, en dus ook een zoekmachine, meteen een complete pagina. Alleen bij client side rendering moet eerst JavaScript draaien voordat er iets te lezen valt.
En in de praktijk mengen moderne frameworks de manieren: de ene pagina vooraf, de andere per verzoek. Een pagina die op de server is opgebouwd, wordt daarna vaak in de browser interactief gemaakt. Dat heet hydration: de browser laadt JavaScript die de knoppen en menu's op de kant-en-klare HTML laat werken. Welke manier een site gebruikt, ligt vast in het framework en de opbouw. Het is dus geen instelling die je later even omzet.
Wat Google doet met JavaScript
Google kan JavaScript uitvoeren. Dat is goed nieuws voor sites die in de browser worden opgebouwd, maar het gebeurt niet meteen. Google verwerkt een pagina in drie stappen.
- Ophalen (crawlen). Googlebot haalt de HTML op en volgt de links die daarin staan.
- Opbouwen (renderen). De pagina gaat in een wachtrij. Daar opent een versie van Chrome de pagina en voert de JavaScript uit. Volgens Google kan een pagina daar een paar seconden staan, maar het kan ook langer duren.
- Opnemen in de index. Pas met de opgebouwde pagina weet Google welke tekst en welke links er echt op staan.
Bij een statische of server-gerenderde pagina staat alles al in stap 1. Bij client side rendering is Google afhankelijk van stap 2. Links die pas door JavaScript verschijnen, worden later ontdekt. En een fout in je JavaScript of een geblokkeerd script kan betekenen dat Google een lege pagina ziet.
Google noemt in zijn documentatie over JavaScript en SEO server side rendering of vooraf renderen nog steeds een goed idee, omdat het je site sneller maakt voor gebruikers en crawlers, en omdat niet alle bots JavaScript kunnen uitvoeren. Drie details die in de praktijk vaak misgaan:
- Noindex in de HTML. Staat er een noindex in de oorspronkelijke HTML, dan kan Google het renderen overslaan. Een noindex die later met JavaScript wordt weggehaald, werkt dus mogelijk niet.
- Links die geen echte links zijn. Google volgt links die als gewone link met een adres in de HTML staan. Een knop of ander element dat pas via JavaScript naar een andere pagina springt, kan Google niet betrouwbaar als link herkennen.
- Dynamic rendering. Daarbij krijgen bots een vooraf gerenderde versie en bezoekers de JavaScript-versie. Google noemt dat een tijdelijke noodoplossing en raadt server side rendering, statisch renderen of hydration aan.
Welke andere SEO-punten bij een headless site goed moeten staan, zoals titels, sitemap en doorverwijzingen, behandel ik in headless website en SEO.
AI-crawlers lezen vaak alleen de eerste HTML
Voor AI-zoekmachines ligt het strenger. Hostingpartij Vercel publiceerde in december 2024 een analyse van het verkeer van AI-crawlers op zijn netwerk. De crawlers van OpenAI, Anthropic, Meta, ByteDance en Perplexity haalden soms JavaScript-bestanden op, maar voerden ze niet uit. Alleen de crawler achter Gemini, die de infrastructuur van Googlebot gebruikt, en die van Apple bouwden pagina's volledig op.
Dat is een momentopname van één partij uit december 2024, en crawlers veranderen. Maar zolang de makers zelf niet laten weten dat ze JavaScript uitvoeren, ga ik ervan uit dat ze alleen lezen wat in de eerste HTML staat. Voor een site die volledig in de browser wordt opgebouwd, betekent dat: voor ChatGPT, Claude of Perplexity bestaat je tekst mogelijk niet. Daarom bouw ik zo dat alle tekst al in de eerste HTML staat. Dan hoef ik niet te gokken wat een crawler wel of niet uitvoert.
Welke crawlers er zijn en hoe je ze toelaat of blokkeert, lees je in robots.txt uitgelegd. Hoe gevonden worden in AI-antwoorden verschilt van gewone SEO, staat in gevonden worden in ChatGPT.
Wat de manier van opbouwen doet met de snelheid
Ook voor bezoekers maakt het verschil. Elke manier heeft een eigen zwakke plek.
- SSG is meestal het snelst. De pagina ligt klaar en wordt geleverd vanaf een server dicht bij de bezoeker. Wat tijd kost, is vooral wat er wordt toegevoegd: grote afbeeldingen, lettertypes, externe scripts.
- SSR laat de server per verzoek werken. Is die server traag, of moet hij eerst gegevens bij een database ophalen, dan wacht de bezoeker op de eerste byte. Hoe je die wachttijd meet, staat in TTFB.
- CSR stuurt snel een lege pagina, maar daarna moet de browser JavaScript downloaden, uitvoeren en vaak nog gegevens ophalen. Op een oudere telefoon zie je dan seconden lang een witte pagina of een laadicoon.
- ISR combineert de snelheid van SSG met verse inhoud, maar vraagt een host en een framework die het ondersteunen.
Of je site snel genoeg is, zie je aan de Core Web Vitals, drie metingen van Google aan echte bezoeken. Wat ze meten en waar de grenzen liggen, vind je in Core Web Vitals uitgelegd.
Waarom je een renderprobleem zelf niet ziet
Het lastige aan client side rendering is dat jij er niets van merkt. Jouw browser voert de JavaScript gewoon uit, dus op je laptop en telefoon ziet de site er perfect uit. Ook je bouwer en je collega's zien niets geks. Het probleem bestaat alleen voor wie geen of later JavaScript uitvoert: zoekmachines, AI-crawlers en de diensten die een voorvertoning maken als iemand je link deelt.
Wat er dan typisch misgaat:
- Elke pagina dezelfde titel. De titel en beschrijving worden pas door JavaScript ingevuld. Een crawler zonder JavaScript ziet overal de standaardtitel, en de voorvertoning in WhatsApp of LinkedIn toont meestal dezelfde algemene tekst.
- Tekst die pas later komt. Inhoud die pas na een klik, een scroll of een extra verzoek wordt geladen, ontbreekt in de eerste HTML.
- Eén fout, een lege pagina. Breekt één script, bijvoorbeeld door een update van een extern pakket, dan blijft de hele pagina leeg voor wie hem op dat moment ophaalt.
De oplossing is zelden een kleine aanpassing. Van client side rendering overstappen naar vooraf of op de server bouwen, raakt de basis van de site en betekent vaak dat een groot deel opnieuw wordt opgezet. Daarom is dit een keuze die je aan het begin maakt, niet een die je achteraf repareert.
Welke manier past bij welke site?
| Type site | Beste manier | Waarom |
|---|---|---|
| Bedrijfssite, blog, kennisbank | SSG | Inhoud verschilt niet per bezoeker, snel en veilig |
| Webshop met wisselende voorraad en prijzen | SSR of ISR | Voorraad en prijzen moeten actueel zijn |
| Nieuwssite | ISR of SSR | Veel nieuwe pagina's per dag |
| Klantportaal of dashboard achter een inlog | CSR of SSR | Persoonlijke gegevens, Google hoeft het niet te zien |
| Web-app zonder zoekverkeer | CSR | Vindbaarheid speelt geen rol |
De vuistregel: alles wat gevonden moet worden, hoort in de eerste HTML. Wat achter een inlog zit, mag in de browser worden opgebouwd.
Mijn maatwerksites bouw ik als statische site met Eleventy. Die keuze maak ik voor je aan het begin van het project, zodat je er later niet meer over hoeft na te denken. De tekst staat dan al in de HTML die de server stuurt, en een menu of filter komt er als klein script bovenop. Begin met HTML die werkt en voeg de rest toe als laag: dat principe heet progressive enhancement. Welke generator bij welke site past, vergelijk ik in static site generator kiezen.
Een snelle test: staat je tekst in de eerste HTML?
Of je huidige site hier last van heeft, kun je globaal zelf zien. Open een pagina in Chrome of Edge en druk op Ctrl+U, op een Mac Cmd+Option+U. Je ziet dan de HTML zoals de server hem stuurt, voordat JavaScript iets doet. Zoek met Ctrl+F of Cmd+F naar een zin uit je tekst. Vind je hem, dan staat hij in de eerste HTML. Zie je vooral een lege container en verwijzingen naar scripts, dan wordt je pagina in de browser opgebouwd. Zo ziet dat er bijvoorbeeld uit:
<body>
<div id="root"></div>
<script src="/assets/index-4f8a2c.js"></script>
</body>
Daar staat geen enkele zin tekst in. Alles wat de bezoeker straks leest, moet het script nog maken. Deze test is een diagnose, geen oplossing: hij vertelt je of je een probleem hebt, niet hoe groot het is of wat het kost om het op te lossen.
Bij een nieuwe site loop ik voor de livegang een vaste reeks controles langs:
| Wat ik controleer | Waarom |
|---|---|
| De belangrijkste tekst van elke pagina staat in de paginabron | Crawlers zonder JavaScript lezen hem ook |
| Elke pagina heeft een eigen titel en beschrijving in de HTML | Goede zoekresultaten en voorvertoningen |
| Menu en interne links zijn gewone links met een adres | Google kan ze volgen |
| Nergens staat een vergeten noindex | Pagina's mogen in de index |
| De URL-inspectie in Search Console toont de pagina zoals bedoeld | Zo ziet Google hem na het renderen |
Hoe die URL-inspectie en de rest van Search Console werken, staat in Google Search Console. Is je site gebouwd met een AI-appbouwer zoals Lovable, dan is dit precies de controle die ertoe doet. Lovable veranderde in 2026 hoe nieuwe projecten worden opgebouwd; wat dat betekent, bespreek ik in Lovable SEO.
Conclusie: zet wat gevonden moet worden in de eerste HTML
Server side rendering, static site generation en incremental static regeneration leveren allemaal een complete pagina af. Client side rendering laat de browser het werk doen, en dat merk je bij Google, dat JavaScript pas in een tweede ronde uitvoert, en vooral bij AI-crawlers, waarvan veel het bij een meting eind 2024 helemaal niet deden. Voor een bedrijfssite is vooraf bouwen meestal de beste keuze; voor wat achter een inlog zit, maakt het weinig uit.
Voor jou betekent dat: de manier van opbouwen is geen detail voor later, maar een keuze die bepaalt of Google en AI-zoekmachines je tekst kunnen lezen. En omdat je een probleem zelf niet ziet, wil je dat iemand het vooraf goed regelt. Daarom kies ik bij mijn maatwerksites vooraf voor statisch bouwen, met alle tekst in de eerste HTML en interactie als laag erbovenop. Voor de livegang loop ik de controles uit dit artikel na, zodat jij er niet naar hoeft te kijken.
Wil je weten wat er bij een headless site verder goed moet staan voor Google? Lees dan headless website en SEO. Benieuwd hoe ik werk? Download het pitchdeck.
Veelgestelde vragen
Is client side rendering slecht voor SEO?
Niet per definitie, maar het maakt je afhankelijker. Google kan JavaScript uitvoeren en een pagina die in de browser wordt opgebouwd dus lezen. Dat gebeurt alleen in een tweede ronde, na een wachtrij, en een fout in je JavaScript kan betekenen dat Google een lege pagina ziet. Andere zoekmachines en veel AI-crawlers voeren weinig of geen JavaScript uit. Voor pagina's die gevonden moeten worden, is het veiliger als de tekst al in de HTML staat die de server stuurt. Achteraf omschakelen is vaak een flinke verbouwing, dus die keuze hoort aan het begin van een project.
Wat is het verschil tussen SSR en SSG?
Bij beide krijgt de bezoeker een complete HTML-pagina. Het verschil zit in het moment. Bij static site generation (SSG) worden alle pagina's vooraf gebouwd, bij elke publicatie, en daarna alleen nog geleverd. Bij server side rendering (SSR) bouwt de server de pagina bij elk verzoek opnieuw op. SSG is sneller en eenvoudiger te hosten, omdat er per bezoek niets hoeft te worden uitgerekend. SSR is nodig als de inhoud per bezoeker of per minuut verschilt, zoals voorraad, prijzen of persoonlijke gegevens.
Wat is hydration?
Hydration is de stap waarin een kant-en-klare HTML-pagina in de browser interactief wordt gemaakt. De server of de bouwstap levert de HTML, zodat bezoeker en zoekmachine meteen inhoud zien. Daarna laadt de browser JavaScript dat knoppen, formulieren en menu's laat werken. Frameworks zoals Next.js doen dat voor de hele pagina. Astro doet het alleen voor losse interactieve onderdelen, wat minder JavaScript kost. Hoe meer er moet worden gehydrateerd, hoe langer een pagina op een trage telefoon nodig heeft om op een tik te reageren.
Kan ChatGPT een website lezen die met JavaScript wordt opgebouwd?
Mogelijk niet. Uit een analyse van Vercel uit december 2024 bleek dat de crawlers van OpenAI, het bedrijf achter ChatGPT, JavaScript-bestanden soms ophaalden maar niet uitvoerden. Hetzelfde gold voor de crawlers van onder meer Anthropic en Perplexity. Staat je tekst pas na het uitvoeren van JavaScript op de pagina, dan zien die crawlers mogelijk een lege pagina. Crawlers veranderen, dus dit kan verschuiven. De veilige keuze is dat je belangrijkste inhoud al in de HTML staat die de server stuurt.
Benieuwd hoe ik dit in de praktijk aanpak?
Het pitchdeck laat de hele werkwijze zien.
Geschreven door Dennis Boekhout
Marketing freelancer uit 's-Hertogenbosch. Volg op LinkedIn (opent in een nieuw tabblad)
