Een websiteformulier dat wel wordt ingevuld
In dit artikel
Formulier conversie verbeter je vooral door het invullen makkelijker te maken. Vraag alleen wat je nodig hebt, zet het label boven elk veld en laat de browser bekende gegevens automatisch invullen. Controleer een veld pas als iemand het verlaat, en zeg in een foutmelding precies hoe het goed komt. Meerdere stappen helpen bij lange formulieren, en een goede bevestiging vertelt wat er nu gebeurt. Die keuzes neem ik mee in de bouw, samen met de techniek, privacy en toegankelijkheid eronder.
Formulier conversie begint bij één vraag: wat heb je nodig?
Elk veld dat je toevoegt, is een reden om af te haken. Iemand moet nadenken, typen en soms iets opzoeken. Formulier conversie, het deel van de bezoekers dat een begonnen formulier ook verstuurt, verbeter je daarom eerst door te schrappen. Pas daarna komen labels, foutmeldingen en techniek.
Bij een nieuw formulier loop ik eerst met de ondernemer elk veld langs, met één vraag: wat doe je met dit antwoord, en heb je het nu nodig of pas later? Een voorbeeld voor het offerteformulier van een installateur:
| Veld | Nodig voor | Advies |
|---|---|---|
| Naam | Aanspreken | Houden, als één veld |
| E-mailadres | Antwoord sturen | Houden |
| Telefoonnummer | Terugbellen | Niet verplicht, of laten kiezen hoe iemand contact wil |
| Postcode | Werkgebied controleren | Houden als je regio uitmaakt |
| Volledig adres | Offerte op locatie | Later vragen, bij de afspraak |
| Bedrijfsnaam | Zakelijke klant herkennen | Alleen als je zakelijk en particulier anders behandelt |
| Hoe ken je ons? | Marketing | Weglaten, meet het met je statistieken |
| Omschrijving | Inschatting van het werk | Houden, met een voorbeeld als hulptekst |
Na zo'n ronde valt vaak hetzelfde op. Voornaam en achternaam als twee velden zijn zelden nodig; één veld "Naam" is sneller en werkt voor elke naam. Een verplicht telefoonnummer levert nepnummers op, of bezoekers die afhaken. Schrappen helpt ook je privacy: een gegeven dat je niet vraagt, hoef je niet te beveiligen of te bewaren. De AVG gaat er bovendien van uit dat je niet meer persoonsgegevens verzamelt dan nodig.
Wat niet verplicht is, krijgt "(niet verplicht)" achter het label, in plaats van een sterretje bij alle verplichte velden. Welke vragen je stelt om een aanvraag goed in te schatten, en hoe AI daarbij helpt, lees je in formulier maken met AI. Voor een webshop gelden dezelfde principes in de afrekenpagina, zie WooCommerce checkout aanpassen.
Labels boven het veld, niet erin
Het label is de tekst die zegt wat er in een veld moet. Het hoort boven het veld: zo lees je label en veld in één beweging, en op een telefoon past het altijd.
Een veelgemaakte fout laat zien hoe ontwerp, techniek, toegankelijkheid en conversie in elkaar grijpen: het label vervangen door een placeholder, de grijze voorbeeldtekst in een leeg veld. Voor het ontwerp is dat strak. Maar zodra iemand typt, verdwijnt de tekst, en wie halverwege twijfelt wat waar hoort, moet het veld weer leegmaken. Grijze placeholdertekst heeft vaak te weinig contrast, en hulpsoftware leest hem niet altijd voor. Het gevolg: meer fouten en meer bezoekers die afhaken.
Onder de motorkap worden label en veld aan elkaar gekoppeld. Dan leest een schermlezer, de voorleessoftware voor blinde en slechtziende bezoekers, het label voor, en kun je op het label klikken om in het veld te komen. Zo ziet dat eruit:
<label for="naam">Naam</label>
<input id="naam" name="naam" type="text" autocomplete="name" required>
<label for="telefoon">Telefoonnummer (niet verplicht)</label>
<p id="telefoon-hint">We bellen alleen als je daarom vraagt.</p>
<input id="telefoon" name="telefoon" type="tel" autocomplete="tel"
aria-describedby="telefoon-hint">
Met aria-describedby hoort de hulptekst bij het veld, zodat een schermlezer die na het label voorleest. Ook de opmaak telt:
- Eén kolom. Velden naast elkaar worden makkelijker overgeslagen of in de verkeerde volgorde ingevuld. Alleen korte velden die bij elkaar horen, zoals postcode en huisnummer, kunnen naast elkaar.
- Breedte past bij het antwoord. Een postcodeveld hoeft niet zo breed als een veld voor een omschrijving.
- Keuzes in een groep. Keuzerondjes of vinkjes staan in een
<fieldset>met de vraag in een<legend>, zodat een schermlezer weet bij welke vraag de opties horen.
Het juiste veld voor het juiste antwoord
Met het juiste type veld helpt de browser je bezoeker. Op een telefoon verschijnt dan het passende toetsenbord, en de browser kan bekende gegevens automatisch invullen.
| Gegevens | HTML | Wat het doet |
|---|---|---|
| E-mailadres | type="email" autocomplete="email" |
Toetsenbord met @, browser vult het adres in |
| Telefoonnummer | type="tel" autocomplete="tel" |
Cijfertoetsenbord, browser vult het nummer in |
| Naam | autocomplete="name" |
Browser vult de naam in |
| Postcode | autocomplete="postal-code" |
Browser vult de postcode in. Geen cijfertoetsenbord: een Nederlandse postcode heeft letters |
| Plaats | autocomplete="address-level2" |
Browser vult de woonplaats in |
| Bedrag | inputmode="decimal" |
Cijfertoetsenbord met komma |
| Eenmalige code | autocomplete="one-time-code" |
Telefoon stelt de code uit een sms voor |
Het kenmerk autocomplete levert de grootste tijdwinst op: wie zijn gegevens in de browser of telefoon heeft opgeslagen, vult met één tik naam, adres en e-mail in. Alle waarden staan in de documentatie van MDN. Het telt ook mee voor toegankelijkheid: WCAG 2.2, de internationale richtlijn voor toegankelijke websites, vraagt dat het doel van velden met persoonsgegevens voor software herkenbaar is (eis 1.3.5, Identificeer het doel van de input). Het zijn kleine kenmerken die je niet ziet als je het formulier bekijkt. Je merkt ze pas als een bezoeker het verkeerde toetsenbord krijgt of alles zelf moet typen.
Twee keuzes die vaak verkeerd uitpakken:
- Een uitklaplijst voor weinig opties. Bij twee tot vijf keuzes zijn keuzerondjes sneller: je ziet alle opties zonder te klikken.
- Een kalender voor een geboortedatum. Terugbladeren naar 1968 is onhandig. Drie losse velden voor dag, maand en jaar werken beter. Voor een afspraak in de komende weken is een kalender wel handig.
Controleren tijdens het typen: wanneer wel en wanneer niet
Controleren tijdens het invullen heet ook inline validatie: het formulier meldt meteen dat iets niet klopt, in plaats van pas na het versturen. Dat helpt, als het op het goede moment gebeurt.
Het slechtste moment is tijdens het typen zelf. Wie begint met een e-mailadres, krijgt na de eerste letter al te horen dat het adres niet klopt. Dat voelt als iemand die over je schouder meekijkt. Beter is controleren zodra iemand een veld verlaat, en de foutmelding weer weghalen zodra het antwoord goed is. Een uitzondering is een veld met eisen die je tijdens het typen kunt afvinken, zoals een nieuw wachtwoord met een minimale lengte.
Technisch zijn er twee lagen:
- De browser zelf. Kenmerken als
requiredentype="email"laten de browser controleren of een veld is ingevuld en op een e-mailadres lijkt. Met de CSS-selector:user-invalidkleurt een veld pas rood nadat de bezoeker ermee bezig is geweest, niet al bij het laden. Die selector werkt sinds eind 2023 in alle grote browsers. - Eigen meldingen met JavaScript. De standaardmeldingen van de browser zien er per browser anders uit en zijn niet altijd duidelijk. Daarom vervang ik ze meestal door eigen meldingen in de stijl van de site; daar is weinig code voor nodig, geen extra pakket.
En dan het belangrijkste, dat een bezoeker nooit ziet: alles wordt opnieuw gecontroleerd op de server, het programma dat het formulier ontvangt. Controle in de browser is gemak voor de bezoeker, geen beveiliging. Wie kwaad wil, stuurt gegevens rechtstreeks naar de server en slaat de browser over.
Foutmeldingen die mensen verder helpen
Een foutmelding moet drie dingen doen: zeggen welk veld het betreft, wat er mis is en hoe het goed komt. Hoe je die woorden kiest, met voorbeelden voor en na, lees je in microcopy. WCAG 2.2 vraagt hetzelfde: een fout wordt in tekst beschreven (3.3.1 Foutidentificatie), en als bekend is hoe het goed moet, krijgt de bezoeker een suggestie (3.3.3 Foutsuggestie).
Daarnaast moet de melding technisch kloppen. Waar je bouwer op moet letten:
- Direct bij het veld, boven of onder het invoerveld, niet alleen bovenaan de pagina.
- Niet alleen rood. Een rode rand ziet niet iedereen. Er hoort altijd tekst bij, eventueel met een pictogram.
- Gekoppeld aan het veld. Met
aria-describedbyleest een schermlezer de melding voor bij het veld, enaria-invalid="true"meldt dat het veld een fout bevat. - Een overzicht na het versturen. Bij een lang formulier komt na een mislukte verzending bovenaan een lijstje met alle fouten, met links naar de velden. De focus springt naar dat lijstje, zodat ook een schermlezer het meteen voorleest.
- Ingevulde gegevens blijven staan. Een formulier dat na een fout alles leegmaakt, is de snelste weg naar een vertrokken bezoeker.
Zo ziet een melding er in de HTML uit:
<label for="email">E-mailadres</label>
<p id="email-fout" class="fout">Vul een e-mailadres in met een @, bijvoorbeeld naam@bedrijf.nl</p>
<input id="email" name="email" type="email" autocomplete="email"
aria-invalid="true" aria-describedby="email-fout">
Eén pagina of meerdere stappen?
Een formulier met meerdere stappen, ook wel een multi-step formulier, verdeelt de vragen over een paar schermen. Dat voelt lichter, vooral bij lange formulieren met logische blokken, zoals een inschrijving of een uitgebreide offerteaanvraag.
| Eén pagina | Meerdere stappen | |
|---|---|---|
| Geschikt voor | Korte formulieren, zoals een contactformulier | Lange formulieren met duidelijke blokken |
| Voordeel | Snel, alles in één overzicht | Minder overweldigend, vragen kunnen afhangen van eerdere antwoorden |
| Nadeel | Een lang formulier schrikt af | Meer klikken en meer bouwwerk |
| Let op | Logische volgorde, korte velden | Voortgang tonen, terug kunnen zonder dat er iets verdwijnt |
Een formulier in stappen staat of valt met vier dingen:
- Makkelijk beginnen. Vragen over de situatie of de wens vooraan, contactgegevens achteraan. Wie al twee stappen heeft ingevuld, maakt het eerder af.
- Zichtbare voortgang, bijvoorbeeld "Stap 2 van 3", met een naam per stap.
- Bewaarde antwoorden. Terug naar een vorige stap mag niets wissen. WCAG 2.2 vraagt bovendien dat je gegevens die iemand in hetzelfde proces al gaf, niet opnieuw laat typen, maar automatisch invult of laat kiezen (3.3.7 Overbodige invoer).
- Een controlestap bij formulieren die iets vastleggen, zoals een inschrijving: een overzicht van alle antwoorden, met de mogelijkheid om iets aan te passen.
Onder de motorkap is dit meer werk dan het lijkt. Op een statische site kun je één formulier in blokken verdelen die met wat JavaScript na elkaar in beeld komen. Zonder JavaScript staan de blokken gewoon onder elkaar en werkt het formulier nog steeds. Die werkwijze heet progressive enhancement.
De bevestiging: wat gebeurt er na het versturen?
Het moment na het versturen wordt vaak vergeten. Toch is daar de twijfel het grootst: is het aangekomen, en wat gebeurt er nu? Een goede bevestiging neemt die twijfel weg.
- Geen dubbele verzending. De verzendknop gaat na één klik uit en het formulier laat zien dat het bezig is, bijvoorbeeld met "Bezig met versturen". Met
role="status"leest een schermlezer die melding voor zonder dat de focus verspringt. - Een eigen bedankpagina met een eigen webadres, die zegt wat er nu gebeurt en wanneer de bezoeker iets kan verwachten. Zo'n pagina is ook het makkelijkste meetpunt. Hoe je dat bezoek in Google Analytics als belangrijke gebeurtenis meetelt, lees je in GA4 instellen.
- Een bevestigingsmail met een samenvatting van wat iemand heeft ingevuld.
- Een inzending die echt aankomt. Een formulier dat er goed uitziet maar niets bezorgt, kost je stilletjes klanten. Bij mijn controle van een wijziging aan een formulier hoort daarom een echte testinzending: komt hij aan, staat alles erin en belandt de bevestigingsmail niet in de spam? Komen berichten bij een bestaande site niet aan, kijk dan bij contactformulier werkt niet.
Gevoelige gegevens en snelheid: de techniek eronder
Een formulier is vaak de pagina waar een bezoeker het meest van zichzelf prijsgeeft. Dat vraagt om een rustige, snelle en veilige pagina, en daar zit werk dat een bezoeker nooit ziet.
Bij een tandartspraktijk met twee locaties heb ik het zo gebouwd dat de pagina's met het inschrijfformulier niets van andere partijen laden, en dat de inschrijvingen versleuteld zijn, zodat ook ik ze als bouwer niet kan lezen. Hoe zo'n formulier werkt en wanneer je het nodig hebt, staat in gevoelige gegevens via je websiteformulier.
Een statische site, zoals ik die bouw, heeft voor een formulier een formulierdienst of een kleine serverfunctie nodig die de inzending ontvangt. Wat zulke functies doen en wat ze kosten, leg ik uit in serverless functies.
Ook bij een gewoon contactformulier geldt: hoe minder scripts van anderen, zoals een chatwidget of advertentiepixel, hoe sneller de pagina reageert en hoe minder gegevens bij partijen terechtkomen die er niets mee te maken hebben.
Conclusie: elk veld moet zijn plek verdienen
Een formulier dat wordt ingevuld, vraagt weinig en maakt het invullen makkelijk: weinig velden, labels boven de velden, de juiste veldtypes, controle op het goede moment en foutmeldingen die zeggen hoe het goed komt. Daaronder zit werk dat een bezoeker nooit ziet: controle op de server, meldingen voor schermlezers, geen onnodige scripts en een inzending die echt aankomt.
Voor jou betekent dat: een formulier is geen blok dat je even toevoegt, maar een klein stuk software op de belangrijkste plek van je site. Ik loop eerst met jou de velden langs en regel daarna de techniek, de toegankelijkheid en de privacy eronder. Verander je later iets aan het formulier, dan test ik het met een echte inzending voordat het live staat.
De woorden in je formulier maken net zoveel verschil als de velden. Over knopteksten, hulpteksten en foutmeldingen gaat microcopy: de kleine teksten op knoppen en formulieren. Benieuwd hoe ik een websitetraject aanpak? Download het pitchdeck.
Veelgestelde vragen
Hoeveel velden mag een contactformulier hebben?
Zo weinig als mogelijk. Voor een gewoon contactformulier zijn naam, e-mailadres en een bericht vaak genoeg. Een telefoonnummer kun je als optie aanbieden voor wie liever gebeld wordt. Elk extra veld vraagt moeite en geeft een reden om af te haken. Vraag je daarom bij elk veld af wat je met het antwoord doet en of je het nu nodig hebt of pas later, bijvoorbeeld bij de afspraak. Gegevens voor je marketing, zoals hoe iemand je vond, meet je beter met je statistieken.
Is een formulier met meerdere stappen beter dan één lange pagina?
Dat hangt af van de lengte. Een kort contactformulier zet je op één pagina; stappen voegen dan alleen klikken toe. Een lang formulier met duidelijke blokken, zoals een inschrijving of een uitgebreide offerteaanvraag, voelt in stappen lichter. Zet de makkelijke vragen vooraan en de contactgegevens achteraan, laat zien hoeveel stappen er zijn en zorg dat teruggaan niets wist. Bij een formulier dat iets vastlegt, zoals een inschrijving, helpt een laatste stap met een overzicht van alle antwoorden.
Moet je een formulier controleren tijdens het typen?
Liever niet tijdens het typen zelf, want dan krijgt iemand al een foutmelding voordat hij klaar is. Controleer een veld zodra de bezoeker het verlaat, en haal de melding weer weg zodra het antwoord klopt. Alleen bij velden met eisen die je kunt afvinken, zoals de lengte van een nieuw wachtwoord, is directe feedback tijdens het typen handig. Controleer daarnaast alles opnieuw op de server, want controle in de browser is gemak voor de bezoeker en geen beveiliging.
Waarom vult de browser mijn formulier niet automatisch in?
Meestal omdat de velden niet goed zijn gemarkeerd. De browser herkent velden aan het kenmerk autocomplete in de HTML, met waarden als name, email, tel en postal-code. Ontbreekt dat, dan moet de browser raden, en dat gaat vaak mis. Soms staat automatisch invullen bewust uit met autocomplete=off. Dat maakt het invullen van gewone velden zoals naam en adres onnodig lastig. De oplossing zit in de code van het formulier. Bij de formulieren die ik bouw, horen de juiste waarden bij de basis, en test ik op een telefoon waarop gegevens zijn opgeslagen.
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)
