Je eerste Node.js server bouwen is makkelijker dan je denkt. Met een paar regels JavaScript heb je een werkende webserver draaien die HTTP-verzoeken afhandelt. In deze handleiding bouw je stap voor stap een server, eerst met de ingebouwde http-module, daarna met het populaire Express-framework.
Aan het einde heb je een draaiende server met routing, JSON-responses en automatische herstart bij code-wijzigingen. Perfect als startpunt voor jouw eerste backend-project.
Wat je nodig hebt voordat je begint
Voordat we gaan coderen, check of je setup klopt:
- Node.js 20 of hoger, download van nodejs.org. Check je versie met
node -v. - Een code editor, VS Code is een populaire keuze onder Node-developers.
- Basis JavaScript-kennis, variabelen, functies en callbacks.
- Terminal-toegang, Terminal op macOS/Linux, PowerShell of Windows Terminal op Windows.
Weet je niet precies hoe Node intern werkt? Lees dan eerst wat Node.js is en hoe de event loop werkt, dat geeft context bij wat we hier gaan bouwen.
Stap 1: Zet een nieuw project op
Open je terminal en maak een nieuwe projectmap aan:
mkdir mijn-eerste-server
cd mijn-eerste-server
npm init -y
Het npm init -y commando genereert een package.json met standaardwaarden. Dit bestand beschrijft jouw project en bevat straks alle dependencies.
Open de map in je editor. Je ziet nu één bestand: package.json. De basis staat klaar.
Stap 2: Bouw een server met de http-module
Maak een nieuw bestand genaamd server.js en plak deze code erin:
const http = require('http');
const server = http.createServer((req, res) => {
res.statusCode = 200;
res.setHeader('Content-Type', 'text/plain; charset=utf-8');
res.end('Hallo vanuit je eerste Node.js server!');
});
const PORT = 3000;
server.listen(PORT, () => {
console.log(`Server draait op http://localhost:${PORT}`);
});
Wat gebeurt hier precies?
http.createServer()maakt een nieuwe server en krijgt een callback die bij elk verzoek wordt aangeroepen.reqis het request-object, bevat URL, headers en methode.resis het response-object, daarmee stuur je data terug.server.listen()start de server op poort 3000.
Run het met:
node server.js
Open je browser en ga naar http://localhost:3000. Je ziet de tekst verschijnen. Gefeliciteerd, je eerste Node.js server draait.
Stap 3: Voeg eenvoudige routing toe
Een echte server reageert verschillend op verschillende URL's. Breid server.js uit:
const http = require('http');
const server = http.createServer((req, res) => {
res.setHeader('Content-Type', 'application/json; charset=utf-8');
if (req.url === '/' && req.method === 'GET') {
res.statusCode = 200;
res.end(JSON.stringify({ bericht: 'Welkom op de homepage' }));
} else if (req.url === '/over' && req.method === 'GET') {
res.statusCode = 200;
res.end(JSON.stringify({ bericht: 'Over deze server' }));
} else {
res.statusCode = 404;
res.end(JSON.stringify({ fout: 'Pagina niet gevonden' }));
}
});
server.listen(3000, () => console.log('Server draait op poort 3000'));
Herstart de server (Ctrl+C en opnieuw node server.js). Test nu http://localhost:3000, /over en een willekeurige andere URL.
Je ziet meteen waarom routing met enkel de http-module snel omslachtig wordt. Voor drie routes gaat het prima, maar bij dertig endpoints heb je een betere oplossing nodig.
Stap 4: Installeer Express voor schaalbare routing
Express is het meest gebruikte framework voor Node.js. Het abstraheert de http-module en geeft je een clean API voor routing, middleware en error handling.
Installeer Express:
npm install express
Maak een nieuw bestand app.js:
const express = require('express');
const app = express();
app.use(express.json());
app.get('/', (req, res) => {
res.json({ bericht: 'Welkom op de homepage' });
});
app.get('/over', (req, res) => {
res.json({ bericht: 'Over deze server' });
});
app.listen(3000, () => {
console.log('Express-server draait op http://localhost:3000');
});
Merk op hoe veel leesbaarder dit is. Elke route is één regel, JSON-parsing werkt automatisch via express.json() en 404's worden standaard afgehandeld.
Start hem met node app.js.
Stap 5: Bouw een POST-endpoint met JSON body
Tot nu toe lazen we alleen data. Tijd om data te ontvangen. Voeg een POST-route toe:
app.post('/gebruikers', (req, res) => {
const { naam, email } = req.body;
if (!naam || !email) {
return res.status(400).json({ fout: 'Naam en email zijn verplicht' });
}
res.status(201).json({
bericht: 'Gebruiker aangemaakt',
gebruiker: { naam, email }
});
});
Test deze route met curl:
curl -X POST http://localhost:3000/gebruikers \
-H "Content-Type: application/json" \
-d '{"naam":"Sander","email":"[email protected]"}'
Dankzij express.json() is req.body automatisch geparsed. Valideer altijd de input voor je iets met de data doet, dat voorkomt crashes en security issues.
Stap 6: Gebruik nodemon voor automatische herstart
Steeds handmatig je server herstarten wordt snel vervelend. Nodemon lost dat op:
npm install --save-dev nodemon
Open package.json en voeg een script toe:
"scripts": {
"dev": "nodemon app.js",
"start": "node app.js"
}
Draai voortaan:
npm run dev
Elke keer dat je een bestand opslaat, herlaadt nodemon je server. Een kleine quality-of-life upgrade die een groot verschil maakt.
Stap 7: Structureer je code voor groei
Zodra je meer dan vijf routes hebt, wordt één bestand onoverzichtelijk. Splits je code op in losse modules:
mijn-eerste-server/
├── app.js
├── package.json
└── routes/
├── gebruikers.js
└── producten.js
In routes/gebruikers.js:
const express = require('express');
const router = express.Router();
router.get('/', (req, res) => {
res.json({ gebruikers: [] });
});
router.post('/', (req, res) => {
res.status(201).json({ bericht: 'Gebruiker aangemaakt' });
});
module.exports = router;
In app.js registreer je de router:
const gebruikersRouter = require('./routes/gebruikers');
app.use('/gebruikers', gebruikersRouter);
Deze scheiding maakt je codebase onderhoudbaar naarmate hij groeit. Elk bestand heeft één verantwoordelijkheid.
Veelgemaakte fouten bij je eerste server
Een paar valkuilen die je beter kunt vermijden:
- Poort al in gebruik, krijg je
EADDRINUSE? Een ander proces draait al op poort 3000. Kies een andere poort of stop het andere proces. - Geen error handling, vergeet niet een catch-all error middleware toe te voegen in Express voor productie.
- Hardcoded configuratie, gebruik environment variables (
process.env.PORT) in plaats van vaste poorten. - Geen input validatie, vertrouw nooit blind op
req.body. Gebruik libraries als Zod of Joi. - Synchrone code in request handlers, blokkeert de event loop. Gebruik altijd async/await of promises bij I/O.
Wat je nu hebt gebouwd
In een half uurtje heb je een werkende Node.js server met:
- Een basis server via de
http-module - Een Express-app met meerdere routes
- Een POST-endpoint dat JSON ontvangt en valideert
- Automatische herstart via nodemon
- Een schaalbare mappenstructuur
Voor productie heb je nog meer nodig: een database, authenticatie, logging, HTTPS en een process manager zoals PM2. Maar de fundering staat.
Veelgestelde vragen
Heb ik Express nodig om een Node.js server te bouwen?
Nee, Node.js heeft een ingebouwde http-module waarmee je zonder extra dependencies een server kunt draaien. Express maakt routing en middleware wel een stuk eenvoudiger, vooral bij grotere projecten.
Op welke poort draait een Node.js server standaard?
Er is geen standaardpoort, maar ontwikkelaars gebruiken meestal poort 3000 of 8080 tijdens development. In productie draait Node vaak achter een reverse proxy zoals Nginx op poort 80 of 443.
Wat is het verschil tussen http.createServer en Express?
http.createServer is de low-level API van Node.js zelf. Express is een framework bovenop http dat routing, middleware en error handling veel makkelijker maakt met minder code.
Hoe herstart ik mijn server automatisch bij wijzigingen?
Gebruik nodemon als dev-dependency. Installeer het met npm install --save-dev nodemon en draai je server met npx nodemon server.js. Je code wordt dan bij elke wijziging automatisch herladen.
Is een Node.js server geschikt voor productie?
Zeker, Node.js draait op grote schaal bij bedrijven als Netflix, LinkedIn en PayPal. Zorg wel voor een process manager zoals PM2, een reverse proxy en goede logging voor een stabiele productiesetup.
Volgende stappen
Nu je een basisserver draaiend hebt, zijn dit logische vervolgstappen: verdiep je in hoe de event loop precies werkt zodat je snapt waarom Node zo goed schaalt bij I/O-intensieve workloads, leer werken met async/await voor database-queries, en voeg authenticatie toe met JWT of sessies.
Begin klein, itereer snel. Dat is de kracht van Node.js, met weinig code krijg je snel iets werkends, en je kunt altijd uitbreiden als je project groeit.