Naar de inhoud
maarten.
Verzameling vintage messing sleutels, verspreid over een donker oppervlak.
Alle stories

API-authenticatie: OAuth en API-sleutels

Maarten Soetens 12 min lezen

API-authenticatie bepaalt welke toepassing of gebruiker toegang krijgt tot een API en welke acties zijn toegestaan. Dit artikel legt uit hoe API-sleutels, OAuth 2.0 en serviceaccounts van elkaar verschillen, en behandelt tokenbeheer, scopes, rotatie en veelvoorkomende beveiligingsfouten.

API-authenticatie begint bij identiteit en toegangsmodel

Je wilt weten of een aanroep klopt én namens wie die aanroep gebeurt. Niet elke API vraagt hetzelfde: soms doet een app iets namens zichzelf, soms vraagt een gebruiker om eigen data. Je kiest dus een methode die past bij de situatie. Identiteit en rechten: dat zijn aparte stappen. Authenticatie: wie is het (klant, app, server)? Autorisatie: wat mag die identiteit daarna doen? Een API-sleutel toont meestal alleen wie de app is, niet precies welke rechten daar bij horen. OAuth 2.0 doet dat anders: daar krijg je een token plus scopes of beleid dat vastlegt wat wel en niet mag.

Voor je kiest: kijk eerst naar wie het verzoek start, hoe lang er toegang nodig is, welke data open moeten en waar je geheime info opslaat. Een sleutel op een backend is makkelijker af te schermen dan een sleutel in zichtbare JavaScript. Zodra je iets niet af kunt schermen, is dat geen veilige oplossing voor serveridentiteit. Voor maatwerk aan de serverkant, bijvoorbeeld met PHP, hoort ook het veilig bewaren van geheimen bij het ontwerp.

Het gaat dus niet om ‘de beste techniek’. Je zoekt wat past bij de identiteit, rechten, levensduur en de plek waar alles draait. Soms voldoet een API-sleutel prima als alleen een machine praat, maar geef je toegang namens gebruikers, dan kom je snel uit bij een OAuth-proces. Die afweging speelt ook bij AI-workflows en automatisering.

API-sleutels: geschikt voor eenvoudige systeemintegraties

Een API-sleutel is meestal gewoon een lange willekeurige string. Je stuurt ‘m mee met elk verzoek, de server zoekt ‘m op en koppelt de sleutel aan een project, gebruiker of integratie. Lekker simpel en handig bij koppelingen tussen twee systemen waar geen gebruikers bij komen kijken. De keerzijde? De sleutel laat niet zien wélke gebruiker iets deed. Deel je dezelfde sleutel met meerdere processen, wordt achteraf lastig wie precies wat deed. En lekt zo’n string uit, blijft die geldig tot je ‘m zelf uitschakelt. Sommige API’s bieden een IP-blokkade, limieten, of beperken toegang tot bepaalde endpoints: gebruik zulke opties als het kan, maar reken er niet alleen op voor je beveiliging. Bij begrensde verzoeken spelen ook API-rate limits een rol.

Stuur sleutels nooit in queryparams mee. Want URL’s komen in logs, browsergeschiedenis, analytics, foutpagina’s. Gebruik altijd de header die de API voorschrijft. Zet headers met secrets liever niet in logs, ook niet tijdens debuggen. En heel belangrijk: geen sleutels in de clientcode van apps, mobiele apps of webbundels. Iedereen die de bestanden ziet, kan ze kopiëren.

API-sleutels zijn niet handig als gebruikers per stuk toestemming moeten geven, als rechten per gebruiker verschillen of als je de toegang snel moet laten verlopen. In die situaties werkt een tokenmodel met duidelijke autorisatie beter. Kies voor sleutels als identiteit van de integratie voldoende is én je makkelijk sleutels bijhouden en intrekken kan.

OAuth 2.0 voor toegang namens een gebruiker

Met OAuth 2.0 geef je een app beperkt toegang tot een API. Vaak gaat de gebruiker via een redirect naar een autorisatiepagina, meldt zich daar aan en beslist of de app mee mag kijken. De app krijgt daarna een access token waarmee aanvragen kunnen worden gedaan. Nooit het echte wachtwoord laten zien aan de app.

Gebruik je een webapp of mobiele app waarmee gebruikers inloggen, dan is Authorization Code met PKCE wat je kiest. Dat is een flow waarbij je een tijdelijke code krijgt en die code inwisselt voor tokens. PKCE is verplicht op plekken waar je geen geheim kunt geheimhouden, zoals in de browser. Voor servers mag een client secret, maar zet die nooit in clientcode. De server bewaart die beter.

OAuth vraagt om discipline: redirect-URI’s exact instellen, state meegeven én zorgvuldig tokens opslaan. Je redirect-URI moet exact overeenkomen met wat je geregistreerd hebt. Geen wildcards gebruiken, een aanvaller kan anders eigen adressen opgeven. State kun je gebruiken om verzoeken aan sessies te koppelen. Tokens horen niet in URL’s of in makkelijk uitleesbare opslag.

OAuth zelf regelt alleen autorisatie. Wil je weten wie de gebruiker echt is, pak dan OpenID Connect erbij. Die voegt een ID-token toe. Let op: access tokens en ID-tokens zijn niet hetzelfde. Verwissel de een niet met de ander.

Serviceaccounts voor geautomatiseerde processen

Een serviceaccount is een account speciaal voor software, niet voor een mens. Handig voor processen die bestanden verwerken, backends die taken doen, of workloads in de cloud. Die accounts kun je rechten geven voor precies één klus, zodat je niet overal persoonlijke logins gebruikt. Ook bij ChatGPT-integraties kan zo’n scheiding tussen gebruikers en software handig zijn.

Let op: wat serviceaccount betekent, verschilt per leverancier. Soms is het een apart account met vaste sleutels, soms een identiteit die je automatisch beschikbaar stelt op de omgeving. OAuth 2.0 Client Credentials is een gangbare manier om een app zónder gebruiker toegang te geven: de app logt in bij de autorisatieserver en ontvangt een access token. ‘Serviceaccount’ en ‘Client Credentials’ zijn niet hetzelfde, maar het overlapt.

Geef processen een eigen identiteit. Gooi niet alle automatisering op één hoop. Zo kun je rechten per workload instellen en zie je bij incidenten sneller welk systeem erbij hoort. Geef alleen de rechten die echt nodig zijn. Een tool die alleen records leest, hoeft geen schrijfrechten. Kan de infrastructuur tijdelijke credentials afgeven? Doen. Dat is veiliger dan een keyfile die nooit vernieuwd wordt. Voor zulke processen zijn bijvoorbeeld n8n-workflows in te richten.

Gebruik serviceaccounts niet als snelle route om gebruikersstappen te omzeilen. Gaat het om toegang namens een gebruiker die iets moet goedkeuren? Dan is delegated OAuth passender. Met het juiste onderscheid houd je controle strakker en is onderzoek achteraf beter te doen.

Scopes, claims en doelbinding beperken API-rechten

Je geeft een toepassing niet automatisch toegang tot alles. Scopes geven aan wat een OAuth-token mag doen: lezen, schrijven, of alleen notificaties ophalen. De autorisatieserver kijkt of die rechten kloppen, vaak met beleid en soms met toestemming van de gebruiker. Daarna moet de API controleren of het token alleen doet wat toegestaan is. Schrijft de API dit niet af, heb je alsnog geen beperking: een scope in een token is pas iets waard als de API de inhoud echt checkt.

Vraag alleen de rechten aan die je nodig hebt. Een scope voor ‘volledige toegang’ betekent meer schade als een token uitlekt. Maak scopes specifiek. Geef bijvoorbeeld toegang tot alleen lezen, wijzigen of werken met beperkte data. Let wel: scopes zijn soms iets anders dan rollen. Een scope is vaak puur een API-recht, rollen zeggen meer over de plek van een gebruiker of proces in je systeem.

Token alleen meenemen voor de juiste doeleinden. Een token voor API X kun je niet veilig bij API Y inzetten. Claims in het token, zoals issuer, audience, en expiry, zijn daarvoor bedoeld. De API zou moeten valideren waar een token vandaan komt, voor wie het gemaakt is, en hoe lang het geldig is. Kijkt de API daar niet naar, dan kun je zelfs met een onderschept token toegang krijgen.

Controleer altijd, bij gevoelige acties, of tokenrechten, context, en scope bij de aanvraag passen. Alleen inloggen of aanwezig zijn is geen recht om op details bij alle gebruikers te zien.

Access tokens en refresh tokens veilig beheren

Een access token gebruik je om een API aan te spreken. De levensduur is meestal kort. Een refresh token laat je nieuwe access tokens ophalen zonder de gebruiker stiekem storen. Hierdoor werken apps prettiger, maar het risico: wie een refresh token te pakken krijgt, kan een tijdlang nieuwe toegang aanvragen.

Waar sla je tokens op? Dat hangt af van je stack. Een backend stopt tokens in de serverstorage, weggehouden van broncode en logs. In een webapp kun je access tokens tijdelijk in geheugen houden. Wil je langer iets opslaan, laat de backend dat doen. Mobiele apps hebben platformbeveiliging zoals een keystore of Secure Enclave. Geen opslag is risicoloos, maar tokens in URL’s of gedeelde mapjes zijn ronduit onveilig.

Houd de geldigheid kort als het risico groot is. Kortere tokens zijn sneller waardeloos bij uitlek, maar vragen vaker een nieuwe. Refresh tokens kun je roteren: na elk gebruik mag de app een nieuw krijgen, de oude wordt direct ongeldig. Komt een oud token terug, let dan op, kan kopiëren zijn of hergebruik. De autorisatieserver kan dan alles uitzetten wat met die familie tokens werkt.

Denk ook aan intrekken en sessies afsluiten. Een access token dat je lokaal valideert blijft geldig tot expiry, tenzij je extra controle doet op intrekking. Bij gevoelige toepassingen kun je tokens kort laten leven, introspectie verplicht stellen of een denylist gebruiken. Loggebruik van tokens? Leg nooit het token zelf vast, wel wie, scope en het resultaat van een aanvraag.

Geheimen roteren zonder integraties uit het oog te verliezen

Sleutels horen te rouleren voor of vlak na het moment dat je ze niet meer vertrouwt. Sleutels, clientsecrets, signingkeys kunnen uitlekken, in repositories, publieke buckets, via logging of door collega’s. Als je nooit wisselt, blijft een oude sleutel mogelijk actief tot ver na het incident. Door routinematig te wisselen verklein je risico’s, maar je moet wel weten waar die sleutel draait en waarvoor.

Beheerst roteren? Gebruik liefst een overlappingsfase waarbij de oude én de nieuwe credential even bruikbaar zijn. Maak de nieuwe sleutel aan, stop ‘m in de secret manager, pas de app aan en kijk in de logs of de nieuwe gebruikt wordt. Daarna trek je de oude in. Niet elke leverancier ondersteunt meer dan één actieve sleutel; soms moet je omschakelen zonder overlap. In zo’n geval moet je deployments goed plannen om uitval te voorkomen.

Leg bij welke geheimen je hebt, wie ze beheert, waar ze gebruikt worden en met welk doel. Zonder overzicht weet je niet wat je straks veilig kan intrekken. Zoek actief naar dode sleutels, dubbele entries en vreemde herkomst. Geheimen horen altijd thuis in een secret manager, niet in een (gedeelde) configfile, codebase of containerimage.

Automatisch rouleren kan foutkansen verkleinen, als je applicatie nieuwe waarden ophaalt en op de juiste manier verwerkt. Test wat er gebeurt als een geheim ongeldig of wegvalt. Een sleutel vervangen zonder monitoring en plan voor intrekken, blijft gewoon een letterwisseling, geen echt beheer.

Veelvoorkomende fouten bij API-authenticatie voorkomen

Regelmatig gaat het mis omdat iemand een geheim in publieke code zet, clientapps, mobiele code of repo’s. Alles dat naar een gebruiker gaat, is uit te lezen. Zelfs als iets in een privé-repo zit, kan het uitlekken via logregels, builds, of per ongeluk ingesloten config. Sleutel uit de code halen is te laat: trek ‘m in, want oude kopieën blijven anders werken.

Tokenwaarden en sleutels kun je onbedoeld loggen. HTTP-headers sneaken in standaardlogs, proxies of tracingtools. Richt logging goed in: redacteer autorisatie-informatie uit logs en scherm gevoelige velden af. Zet credentials alleen over versleutelde verbindingen. Hang ze niet in de URL, want die komt overal terug: logs, browsers, monitoring.

Ook te brede rechten en gedeelde accounts maken het onoverzichtelijk. Als een API-sleutel alles mag en door iedereen wordt gebruikt, groeit het risico en zie je minder snel waar het fout gaat. Richt rechten per app en omgeving in. Gebruik andere credentials voor development, testen en live, zodat testdata niet op live-resources terechtkomen.

Vergeet de validatie aan AP kant niet. De API moet handtekening of sleutel controleren, expiry en doelgroep in het token natrekken en alleen gevraagde acties toestaan. Geloof nooit wat een client zelf aanlevert over zichzelf. Test situaties waarin het fout zou moeten gaan: verlopen tokens, verkeerde scope, onbekende issuer, ingetrokken sleutel, of toegang tot andermans record. Die verzoeken horen afgewezen te worden zonder gevoelige info terug te sturen. Ook logging en foutafhandeling helpen om problemen met integraties te onderzoeken.

Veelgestelde vragen

Is HTTPS genoeg om een API te beveiligen?

Nee, alleen HTTPS is niet genoeg. HTTPS versleutelt het verkeer, zodat niemand meekijkt of wijzigt tijdens transport. Maar hiermee weet een API nog niet wie aanroept of of dat mag. De API moet daarnaast zelf bepalen wie toegang krijgt en wat iemand mag aanvragen. Houd ook antwoorden klein en leg limieten op. HTTPS is dus belangrijk, maar je hebt daarnaast nog echte authenticatie en autorisatie nodig.

Wat is het verschil tussen JWT- en opaque access tokens?

Bij een JWT kun je claims lokaal uitlezen; een opaque token bevat geen zichtbare info. Met JWT kan de API direct controleren: handtekening klopt, expiry, audience oké. Maar vertrouw niet blind op de inhoud alleen. Opaque tokens kun je alleen bij de autorisatieserver natrekken, meestal met introspectie. JWT's versnellen lokale validatie, maar zijn lastiger direct ongeldig te maken na uitgifte. Opaque tokens bieden een centraal controlepunt, wel iets meer netwerklast.

Hoe voorkom je replayaanvallen op een API?

Door elk verzoek zo vorm te geven dat een onderschept verzoek niet onbeperkt werkt. Standaard: altijd HTTPS gebruiken. Beperk de levensduur van gevoelige acties. Je kunt per protocol een nonce, timestamp of handtekening over de inhoud meesturen zodat een kopie wordt herkend en geweigerd. Hou een lijstje van gebruikte nonces of idempotency keys kort bij voor hele gevoelige handelingen, zo voorkom je dubbele uitvoering.

Hoe test je API-authenticatie veilig zonder productiedata?

Gebruik een aparte testomgeving met testaccounts, nep-data en credentials die niet voor productie gelden. Zo voorkom je dat echte gebruikers of systemen geraakt worden. Test succesvolle én foutscenario’s: missende, foute en verlopen tokens, te weinig rechten. Beheer testgeheimen net zo netjes als in productie en log ze nergens bewust. Zorg ervoor dat de testomgeving ook echt geen toegang heeft tot productie.

Moet elke microservice een token controleren als er al een API-gateway is?

Ja, microservices met gevoelige data of logica moeten zelf controleren of een verzoek rechtmatig is. Een API-gateway kan eerste checks doen, zoals afwijzen zonder token, maar soms gaat verkeer buiten die omweg om. Dus: zorg voor goede netwerksegmentatie en valideer in elke service de relevante tokeninfo. Reken niet alleen op headers van een gateway, tenzij een onbevoegde die headers niet kan namaken.

Foto: Magda Ehlers

Portret van Maarten

Maarten

Freelance developer in Nijmegen

Even kennismaken?

Vertel kort wat er speelt. Dan hoor je wat er kan, wat ik anders zou doen en waar AI bij jou wél en niet iets toevoegt. Vrijblijvend.

Het kantoor in Nijmegen
© 2026 maarten.online Sitemap Privacy Algemene voorwaarden
Het kantoor in Nijmegen

Maarten.

Freelance developer in Nijmegen. Liever direct contact? Dat kan ook.

Kennismaken

Laat je gegevens achter, dan kijken we of het klikt. Vrijblijvend en zonder verkooppraat.

Maarten

Stuur een bericht via WhatsApp

Hoi! Waar kan ik je mee helpen?

nu