Express.js: Deine erste REST-API mit Node.js bauen

Wenn du in Node.js schon mit einzelnen Skripten und Modulen gearbeitet hast, ist der nächste logische Schritt oft eine eigene Web-API: ein Server, der auf Anfragen aus dem Netz reagiert und Daten zurückliefert. Genau dafür ist Express gemacht – das meistgenutzte Web-Framework für Node.js. Es nimmt dir die mühsame Arbeit mit dem rohen http-Modul ab und lässt dich in wenigen Zeilen eine funktionierende REST-API aufsetzen. In diesem Beitrag baust du Schritt für Schritt eine kleine API zum Verwalten einer To-do-Liste und lernst dabei die wichtigsten Bausteine kennen.

Was ist eine REST-API?

Eine REST-API ist eine Schnittstelle, über die ein Client (z. B. ein Browser oder eine App) mit deinem Server kommuniziert – und zwar über die ganz normalen HTTP-Methoden. Jede Methode hat dabei eine klare Bedeutung: GET liest Daten, POST legt neue an, PUT oder PATCH aktualisieren, und DELETE löscht. Angesprochen werden immer Ressourcen, die über eine URL identifiziert werden.

• GET /todos – alle To-dos abrufen
• GET /todos/1 – ein einzelnes To-do abrufen
• POST /todos – ein neues To-do anlegen
• DELETE /todos/1 – ein To-do löschen

Der Server antwortet mit Daten (meist als JSON) und einem Status-Code, der verrät, ob alles geklappt hat. Diese Konventionen machen eine API vorhersehbar – jeder Entwickler weiß sofort, was zu erwarten ist.

Express installieren und den Server starten

Zuerst legst du ein neues Projekt an und installierst Express. Achte darauf, dass in deiner package.json der Eintrag "type": "module" steht, damit du moderne import-Syntax nutzen kannst.

mkdir todo-api && cd todo-api
npm init -y
npm install express

Jetzt erstellst du eine Datei server.js mit dem minimalen Grundgerüst:

import express from "express";

const app = express();

// Damit Express JSON aus dem Request-Body lesen kann:
app.use(express.json());

app.get("/", (req, res) => {
  res.send("Die API läuft!");
});

const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Server läuft auf http://localhost:${PORT}`);
});

Mit node server.js startest du den Server. Rufst du http://localhost:3000 im Browser auf, siehst du die Begrüßung. Der Aufruf express.json() ist übrigens wichtig: Ohne diese Zeile wäre req.body bei POST-Anfragen schlicht undefined.

Routen definieren: die HTTP-Methoden

Eine Route verbindet eine HTTP-Methode und eine URL mit einer Funktion, die die Anfrage bearbeitet. Diese Funktion bekommt zwei Objekte: req (die eingehende Anfrage) und res (die Antwort, die du zurückschickst). Lass uns die To-dos in einem einfachen Array im Speicher verwalten.

let todos = [
  { id: 1, text: "Express lernen", done: false },
];
let nextId = 2;

// Alle To-dos zurückgeben
app.get("/todos", (req, res) => {
  res.json(todos);
});

// Ein neues To-do anlegen
app.post("/todos", (req, res) => {
  const neues = { id: nextId++, text: req.body.text, done: false };
  todos.push(neues);
  res.status(201).json(neues);
});

Beachte den res.status(201)-Aufruf beim Anlegen: Der Code 201 Created signalisiert, dass eine neue Ressource entstanden ist. Mit res.json() wandelt Express das Objekt automatisch in JSON um und setzt den passenden Content-Type-Header.

Für einzelne Ressourcen nutzt du Routenparameter. Der Platzhalter :id in der URL landet in req.params:

// Ein To-do löschen
app.delete("/todos/:id", (req, res) => {
  const id = Number(req.params.id);
  const vorher = todos.length;
  todos = todos.filter((t) => t.id !== id);

  if (todos.length === vorher) {
    return res.status(404).json({ error: "To-do nicht gefunden" });
  }
  res.status(204).end();
});

Hier siehst du gleich zwei nützliche Status-Codes: 404 Not Found, wenn es das To-do gar nicht gibt, und 204 No Content für ein erfolgreiches Löschen, bei dem keine Daten zurückkommen.

Middleware: der Kern von Express

Middleware sind Funktionen, die zwischen dem Eingang einer Anfrage und der finalen Antwort ausgeführt werden. Genau das war schon express.json(). Du kannst aber auch eigene Middleware schreiben – etwa um jede Anfrage zu protokollieren. Wichtig ist der dritte Parameter next: Erst der Aufruf von next() gibt die Kontrolle an die nächste Funktion weiter.

function logger(req, res, next) {
  console.log(`${req.method} ${req.url}`);
  next(); // ohne diesen Aufruf bleibt die Anfrage hängen!
}

app.use(logger);

Middleware wird in der Reihenfolge durchlaufen, in der du sie registrierst. Deshalb solltest du globale Middleware wie logger oder express.json() immer vor deinen Routen definieren. So baust du dir nach und nach eine ganze Kette von Bausteinen: Logging, Authentifizierung, Validierung – jeder Schritt kann die Anfrage prüfen, verändern oder abbrechen.

Fehler sauber behandeln

Damit deine API robust bleibt, brauchst du eine zentrale Stelle für Fehler. Express erkennt eine Error-Handling-Middleware daran, dass sie vier Parameter hat: (err, req, res, next). Sie gehört ans Ende, nach allen Routen.

// 404 für unbekannte Routen
app.use((req, res) => {
  res.status(404).json({ error: "Route nicht gefunden" });
});

// Zentraler Fehler-Handler
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: "Interner Serverfehler" });
});

Der erste Block fängt alle URLs ab, für die es keine passende Route gibt. Der zweite reagiert auf unerwartete Fehler und antwortet mit 500 Internal Server Error, statt den Server abstürzen zu lassen. So bekommt der Client immer eine saubere, verständliche Antwort – und du behältst über console.error den Überblick, was schiefgelaufen ist.

Fazit

Mit Express hast du in kurzer Zeit eine vollständige REST-API gebaut: Du kennst jetzt die HTTP-Methoden und ihre Bedeutung, definierst Routen mit Parametern, setzt aussagekräftige Status-Codes und nutzt Middleware als flexible Bausteine – inklusive zentralem Fehler-Handling. Als Nächstes kannst du das In-Memory-Array durch eine echte Datenbank ersetzen, Eingaben validieren und eine Authentifizierung ergänzen. Aber das Fundament steht: Du verstehst, wie moderne Web-APIs aufgebaut sind und wie du sie mit Node.js selbst umsetzt.