Wat is een webhook? Zo laten systemen elkaar automatisch iets weten
In dit artikel
Een webhook is een automatisch bericht dat het ene systeem naar het andere stuurt zodra er iets gebeurt, zoals een gelukte betaling of een nieuw ingevuld formulier. Het werkt als een deurbel: in plaats van steeds te gaan kijken of er post is, word je gewaarschuwd. Het ontvangende systeem heeft daarvoor een eigen adres, de webhook-URL. Een goede ontvanger controleert of een bericht echt van de afzender komt en vangt mislukte berichten op. Zo'n ontvanger bouw ik mee als ik een site maak, en ik houd hem daarna bij.
Wat is een webhook? De deurbel in plaats van steeds gaan kijken
Stel dat je een pakket verwacht. Je kunt elk kwartier naar de voordeur lopen om te kijken of het er al is. Of je wacht tot de bezorger aanbelt. Het eerste kost veel loopwerk, en meestal is er niets. Het tweede werkt alleen als je een deurbel hebt.
Systemen hebben hetzelfde probleem. Je website wil weten of een betaling gelukt is. Hij kan de betaalprovider elke minuut vragen hoe het ervoor staat; dat heet polling. Of de betaalprovider belt zelf aan zodra de betaling rond is. Dat aanbellen is een webhook.
Technisch is een webhook een gewoon webverzoek dat systeem A naar een adres van systeem B stuurt, meestal met een klein pakketje gegevens in JSON, een tekstformaat dat programma's makkelijk lezen. Dat adres heet de webhook-URL. Het wordt één keer opgegeven bij systeem A, en vanaf dan krijgt systeem B bij elke gebeurtenis bericht.
Zo ziet zo'n bericht er vereenvoudigd uit:
POST https://www.voorbeeld.nl/api/betaling
Content-Type: application/json
{ "gebeurtenis": "betaling.gelukt", "id": "pay_8f3k2", "bedrag": "49.95" }
Aan de ontvangende kant moet iets draaien dat zo'n bericht aanneemt en verwerkt. Bij een statische website is dat meestal een serverfunctie: een klein stukje code bij je host dat alleen wakker wordt als er een verzoek binnenkomt. Hoe zo'n functie werkt en waar zijn grenzen liggen, beschrijf ik in serverless functies. Die ontvanger is het deel waar het vakwerk zit, zoals je verderop leest.
Webhook vs API: twee richtingen van hetzelfde gesprek
Een API is het loket van een programma: jij gaat erheen en vraagt iets. Een webhook is de omgekeerde richting: het programma komt naar jou toe zodra er iets verandert. Dat loket werk ik verder uit in wat is een API-koppeling.
| API | Webhook | |
|---|---|---|
| Wie neemt het initiatief? | Jouw systeem vraagt | Het andere systeem meldt |
| Wanneer? | Wanneer jij wilt | Zodra er iets gebeurt |
| Nadeel | Veel vragen voor niets, of je bent te laat | Je hebt een adres nodig dat altijd bereikbaar is |
| Typisch gebruik | Gegevens opvragen of aanmaken | Een seintje bij een gebeurtenis |
In de praktijk werken ze bijna altijd samen. De webhook zegt dat er iets gebeurd is, en met de API worden daarna de details opgehaald. Dat is ook veiliger, zoals je verderop leest.
Drie voorbeelden uit de praktijk
Betaling gelukt
Een klant betaalt via iDEAL of creditcard en wordt teruggestuurd naar je site. Op dat terugkomen kun je niet bouwen: de klant kan het venster sluiten of de verbinding valt weg. Daarom sturen betaalproviders een webhook zodra de status verandert. Pas als die binnen is, gaat de bestelling op betaald en gaat de bevestiging de deur uit. Een site die een bestelling al op betaald zet zodra de klant op de bedankpagina komt, gaat vroeg of laat de mist in.
Mollie doet dat op een slimme manier. De webhook bevat alleen het nummer van de betaling, niet de status. Die haalt de ontvanger daarna zelf op via de API. Een nepbericht levert een aanvaller dus niets op, want jouw systeem vraagt bij Mollie zelf na hoe het zit. Welke betaalprovider bij je past, lees je in Mollie of Stripe.
Formulier naar je CRM
Iemand vult het offerteformulier op je website in. De formulierdienst stuurt een webhook naar je CRM, of naar een kleine functie die het bericht omzet, en de aanvraag staat direct klaar voor opvolging. Geen kopiëren uit je mailbox meer, en geen aanvraag die tussen de nieuwsbrieven verdwijnt. Een overzicht van CRM-pakketten voor kleine bedrijven staat in CRM voor het mkb.
Let wel op wat er meegaat. Een webhook vervoert in dit geval persoonsgegevens, dus het ontvangende adres moet https gebruiken en je wilt weten via welke partijen de gegevens lopen en waar ze terechtkomen.
Nieuwe inhoud start een nieuwe build
Bij een statische website worden alle pagina's vooraf gebouwd. Wordt een tekst aangepast in een headless CMS, een beheersysteem dat los van de site staat, dan moet de site opnieuw worden gebouwd. Daarvoor heeft de host een build hook: een uniek webadres dat een nieuwe build start zodra er een bericht binnenkomt. Bij Netlify hoort dat bij de instellingen van een project. Het CMS stuurt bij elke publicatie een webhook naar dat adres, en de nieuwe versie gaat vanzelf live. Welke headless CMS'en er zijn, vergelijk ik in headless CMS vergelijken.
Mijn eigen sites hebben zo'n CMS niet nodig: ik pas de bestanden zelf aan, en na mijn controle start de nieuwe build vanuit versiebeheer. Wat er bij zo'n build en publicatie allemaal gebeurt, staat in wat is deployen.
Beveiliging: controleer wie er aanbelt
Een webhook-URL is een openbaar adres op internet. Iedereen die het kent, kan er een bericht naartoe sturen. Zonder controle kan een aanvaller dus een nepmelding sturen dat een bestelling betaald is. Daarom hoort bij elk bericht de controle of het echt van de afzender komt.
De gangbare manier is een handtekening. De afzender en de ontvanger delen een geheime code. Bij elk bericht berekent de afzender met die code en de inhoud van het bericht een handtekening en stuurt die mee. De ontvanger rekent hetzelfde na. Klopt de uitkomst, dan komt het bericht van de afzender en is het onderweg niet aangepast.
Stripe stuurt die handtekening mee in een eigen kopregel en verwerkt er een tijdstempel in, zodat een onderschept bericht niet later opnieuw kan worden afgespeeld. Hoe dat precies werkt, staat in de documentatie van Stripe over webhooks. Netlify ondertekent zijn uitgaande webhooks als er een geheime code voor is ingesteld.
Zo'n controle is maar een paar regels code, maar één fout en je systeem accepteert nepberichten of weigert echte. Die regels laat ik door mijn codeer-agent schrijven, maar of ze echte berichten doorlaten en valse weigeren, controleer ik zelf, voordat er een echte betaling doorheen gaat. Daarnaast hoort bij een goede ontvanger:
- De inhoud niet blind vertrouwen. Belangrijke gegevens, zoals de status van een betaling, worden apart opgehaald via de API, zoals Mollie het voorschrijft.
- Altijd https. Dan kan niemand het bericht onderweg meelezen.
- Adres en geheime code buiten de code. Niet in de bestanden van de website en niet in een openbare repository. Een build hook die uitlekt, kan iedereen gebruiken om builds te starten, en bij hosts die per publicatie rekenen, kost dat geld.
- Alleen verwerken wat je verwacht. Alleen de soorten gebeurtenissen afnemen die nodig zijn en de rest negeren.
Wat als een webhook mislukt?
Webhooks gaan soms mis. Je server is even niet bereikbaar, je functie loopt vast of doet er te lang over. Goede afzenders proberen het dan opnieuw. Twee voorbeelden, stand november 2026:
| Afzender | Wanneer geldt het als mislukt? | Hoe vaak opnieuw? |
|---|---|---|
| Mollie | Geen antwoord 200 OK binnen 15 seconden | 10 keer in totaal, met steeds langere tussenpozen, verspreid over ongeveer 26 uur |
| Stripe | Geen antwoord in de 200-reeks, of te laat | Tot drie dagen lang, met steeds langere tussenpozen |
Daar volgen vier eisen uit voor de ontvangende kant:
- Snel antwoorden. Eerst bevestigen dat het bericht binnen is, daarna het zware werk. Een koppeling die eerst een factuur maakt en dan pas antwoordt, loopt het risico dat de afzender afhaakt en hetzelfde bericht opnieuw stuurt.
- Rekenen op dubbele berichten. Door die herhalingen kan hetzelfde bericht twee keer binnenkomen. De ontvanger moet bijhouden welke berichten al verwerkt zijn, zodat een klant niet twee bevestigingsmails krijgt en een bestelling niet dubbel wordt ingeboekt.
- Niet rekenen op de volgorde. Stripe garandeert bijvoorbeeld niet dat berichten aankomen in de volgorde waarin ze zijn ontstaan. Bij twijfel haalt de ontvanger de actuele stand op via de API.
- Alles loggen en laten melden. Elk binnenkomend bericht en elke fout wordt weggeschreven. Gaat het mis, dan krijgt iemand een melding voordat de klant belt. Hoe je zo'n melding betrouwbaar inricht, bespreek ik in uptime-monitoring.
Stopt de afzender na al zijn pogingen, dan komt het bericht niet meer vanzelf. Bij Mollie kun je een webhook niet zelf opnieuw laten versturen; daarvoor moet je bij hun support aankloppen. In het dashboard van Stripe kan het wel, tot vijftien dagen na de gebeurtenis. Daarom is het verstandig om belangrijke zaken, zoals openstaande betalingen, ook periodiek via de API na te lopen.
Checklist: waar een goede webhook aan voldoet
Gebruik deze lijst in het gesprek met je bouwer. Zijn de antwoorden vaag, vraag dan door.
| Controle | Waarom |
|---|---|
| Het adres gebruikt https | Niemand leest onderweg mee |
| De handtekening wordt gecontroleerd | Nepberichten worden geweigerd |
| Belangrijke gegevens worden via de API nagevraagd | De inhoud van het bericht is niet doorslaggevend |
| Het antwoord komt binnen een paar seconden | Geen onnodige herhalingen |
| Dubbele berichten worden herkend | Geen dubbele mails of boekingen |
| Elk bericht en elke fout wordt gelogd | Je kunt terugzoeken wat er gebeurd is |
| Bij fouten gaat een melding naar een vaste persoon | Iemand grijpt in voordat de klant het merkt |
| Het adres en de geheime code staan niet in de code | Ze kunnen niet uitlekken via de website of een repository |
| Test- en live-instellingen zijn gescheiden | Testbetalingen raken je echte boekhouding niet |
| Getest met een testbericht van de afzender | Je weet dat het werkt voordat het ertoe doet |
Twee fouten zie je vaak pas als het te laat is. Betaalproviders werken met een testomgeving en een live-omgeving, met eigen sleutels en soms eigen webhook-instellingen. Staat bij de livegang één onderdeel nog op test, dan lopen betalingen en bestellingen uit de pas. En bij een nieuwe site of een nieuw domein moeten alle webhook-adressen mee. Daarom leg ik bij de livegang van een nieuwe site eerst vast wat er al draait, van DNS-instellingen en mail tot koppelingen met andere systemen. Webhook-adressen horen in datzelfde rijtje.
Automatiseringstool of een gebouwde ontvanger?
Een webhook kan worden ontvangen door een stukje code dat voor je site is gebouwd, of door een automatiseringstool. Zapier, Make en n8n geven je een webhook-adres en laten je bij elkaar klikken wat er daarna moet gebeuren. Dat werkt voor eenvoudige stappen, zoals een nieuwe aanvraag in een spreadsheet zetten. Welke van de drie bij je past, vergelijk ik in Zapier vs Make vs n8n.
Een gebouwde ontvanger in een serverfunctie is logischer als er geld of gevoelige gegevens mee gemoeid zijn, als de handtekening gecontroleerd moet worden op een manier die de tool niet ondersteunt, of als je niet wilt dat gegevens via nog een extra partij lopen. Bij een betaalflow kies ik daarom voor eigen code, met een duidelijke logregel bij elk bericht.
Conclusie: een webhook is een seintje, geen bewijs
Een webhook laat het ene systeem het andere automatisch waarschuwen zodra er iets gebeurt, zonder dat er steeds gevraagd hoeft te worden. Dat maakt betalingen, formulieren en publicaties sneller en betrouwbaarder. Behandel een webhook wel als een seintje en niet als bewijs: de handtekening controleren, belangrijke gegevens navragen via de API, snel antwoorden en alles loggen.
Voor jou betekent dat: een webhook-adres invullen is het makkelijke deel, de ontvanger betrouwbaar maken is het vakwerk. Daar zit het verschil tussen een betaalflow die klopt en een bestelling die stilletjes blijft hangen. Die ontvanger bouw ik mee als ik je site maak, en daarna houd ik hem in het beheer bij. Jij hoort pas iets als er een beslissing van jou nodig is.
Wil je weten waar zo'n webhook op een statische website binnenkomt? Lees dan serverless functies. Benieuwd hoe ik werk? Download het pitchdeck.
Veelgestelde vragen
Wat is een webhook-URL?
Een webhook-URL is het adres waar een ander systeem zijn berichten naartoe stuurt, het adres van je deurbel. Het hoort bij het systeem dat de berichten ontvangt, bijvoorbeeld een serverfunctie op je website, je CRM of een automatiseringstool, en wordt opgegeven bij het systeem dat de berichten verstuurt, zoals je betaalprovider. Het adres moet https gebruiken en altijd bereikbaar zijn. Verhuist je site naar een nieuw domein of een nieuwe opzet, dan moet het adres mee, anders komen de berichten nergens aan. Houd het bovendien voor jezelf, want wie het kent, kan er berichten naartoe sturen.
Wat is het verschil tussen een webhook en een API?
Bij een API neemt jouw systeem het initiatief: het vraagt iets op of maakt iets aan bij een ander systeem. Bij een webhook neemt het andere systeem het initiatief: het meldt zich bij jou zodra er iets gebeurt, zoals een gelukte betaling. Een API is dus vragen, een webhook is gewaarschuwd worden. In de praktijk werken ze samen. De webhook geeft een seintje, en daarna haalt je systeem met de API de actuele gegevens op. Dat is sneller dan steeds vragen en veiliger dan blind vertrouwen op het bericht.
Zijn webhooks veilig?
Ze zijn veilig als de ontvanger goed controleert. Een webhook-adres is bereikbaar vanaf internet, dus iedereen die het kent, kan er een bericht naartoe sturen. Daarom ondertekenen de meeste afzenders hun berichten met een geheime code die alleen zij en de ontvanger kennen. De ontvanger rekent die handtekening na en weigert berichten die niet kloppen. Verder hoort er altijd https bij, staan het adres en de geheime code niet in de code of de repository, en worden belangrijke gegevens, zoals de status van een betaling, apart opgehaald via de API.
Wat gebeurt er als mijn website offline is als er een webhook binnenkomt?
Dan mislukt de aflevering. Goede afzenders proberen het daarna opnieuw, met steeds langere tussenpozen. Mollie roept je adres in totaal tien keer aan, verspreid over ongeveer 26 uur, en Stripe probeert het tot drie dagen lang (stand november 2026). Ben je binnen die tijd weer bereikbaar, dan komt het bericht alsnog aan. Daarna stopt de afzender. Daarom hoort bij een goede ontvanger dat fouten worden gelogd, dat er een melding komt als hij niet werkt en dat belangrijke zaken, zoals openstaande betalingen, ook via de API worden nagekeken.
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)
