Node.js desde cero: guia completa para crear APIs REST con Express 2026

Node.js ha revolucionado el desarrollo backend al permitir usar JavaScript en el servidor. Si ya conoces JavaScript para el frontend, aprender Node.js es el paso natural para convertirte en un desarrollador fullstack. En esta guia completa vamos a ver todo lo que necesitas para empezar con Node.js y construir tu primera API REST con Express en 2026.

Que es Node.js y para que sirve

Node.js es un entorno de ejecucion de JavaScript construido sobre el motor V8 de Google Chrome. Lo que lo hace especial es que permite ejecutar JavaScript fuera del navegador, directamente en el servidor o en tu ordenador local. Antes de Node.js, JavaScript era exclusivo del frontend. Con Node.js, puedes usar el mismo lenguaje tanto en el cliente como en el servidor.

Node.js utiliza un modelo de entrada y salida asíncrono y orientado a eventos, lo que lo hace extremadamente eficiente para manejar muchas conexiones simultaneas. Es la tecnologia detras de empresas como Netflix, LinkedIn, PayPal y Uber, que lo usan para gestionar millones de peticiones diarias.

Por que aprender Node.js en 2026

Hay varias razones de peso para aprender Node.js este ano:

• Unificacion del lenguaje: Si ya sabes JavaScript, no tienes que aprender un nuevo lenguaje para el backend. Usas las mismas estructuras, la misma sintaxis y muchos de los mismos patrones.
• Ecosistema npm enorme: npm (Node Package Manager) es el mayor repositorio de paquetes de software del mundo, con mas de 2 millones de paquetes disponibles.
• Alta demanda laboral: Node.js es una de las tecnologias mas solicitadas en ofertas de trabajo de desarrollo web en 2026.
• Rendimiento excepcional: Para aplicaciones en tiempo real, APIs y microservicios, Node.js ofrece un rendimiento sobresaliente gracias a su arquitectura no bloqueante.
• Comunidad activa: Miles de desarrolladores contribuyen constantemente al ecosistema de Node.js.

Como instalar Node.js paso a paso

Antes de escribir codigo, necesitas instalar Node.js en tu sistema. Hay varias formas de hacerlo, pero te recomiendo usar nvm (Node Version Manager) que es la opcion mas flexible para gestionar diferentes versiones de Node.js:

Instalar con nvm (recomendado)

En macOS y Linux, ejecuta este comando en tu terminal:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

Despues, instala la version LTS (Long Term Support) de Node.js:

nvm install --lts
nvm use --lts

En Windows, descarga el instalador directamente desde nodejs.org o usa nvm-windows. Verifica que la instalacion fue correcta:

node --version  # Deberia mostrar algo como v22.x.x
npm --version   # Deberia mostrar algo como 10.x.x

Tu primer programa con Node.js

Antes de construir una API completa, vamos con lo basico. Crea un archivo llamado app.js y escribe:

// app.js - Tu primer programa Node.js
const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
  res.end('Hola desde Node.js! Bienvenido a TuRinconDev.');
});

const PORT = 3000;
server.listen(PORT, () => {
  console.log('Servidor corriendo en http://localhost:' + PORT);
});

Para ejecutarlo, abre una terminal en la carpeta donde guardaste el archivo y escribe:

node app.js

Abre tu navegador en http://localhost:3000 y veras el mensaje. Acabas de crear tu primer servidor web con Node.js. Aunque esto funciona, en la practica nadie construye servidores HTTP directamente con el modulo http de Node.js. Para eso existe Express.

Que es Express y por que usarlo

Express es el framework web mas popular para Node.js. Es minimalista, flexible y extremadamente maduro. Facilita enormemente la creacion de aplicaciones web y APIs al proporcionar un conjunto de funcionalidades robustas sin ser opinionado sobre como debes estructurar tu proyecto.

Con Express puedes manejar rutas, middleware, errores y mucho mas con una sintaxis limpia y sencilla. Es el framework que han aprendido millones de desarrolladores Node.js y es practicamente un estandar de facto en el ecosistema.

Creando tu primera API REST con Express paso a paso

Paso 1: Inicializar el proyecto

Crea una nueva carpeta para tu proyecto y navega a ella:

mkdir mi-primera-api
cd mi-primera-api
npm init -y

El comando npm init -y crea un archivo package.json con la configuracion basica del proyecto.

Paso 2: Instalar Express

npm install express

Opcionalmente, instala nodemon para que el servidor se reinicie automaticamente cuando cambies el codigo:

npm install --save-dev nodemon

Paso 3: Crear la estructura del proyecto

Organiza tu proyecto con esta estructura de carpetas:

mi-primera-api/
├── src/
│   ├── routes/
│   │   └── productos.js
│   ├── controllers/
│   │   └── productosController.js
│   ├── data/
│   │   └── productos.js
│   └── app.js
├── package.json
└── .gitignore

Paso 4: Crear el servidor Express

Crea el archivo principal src/app.js:

// src/app.js
const express = require('express');
const productosRouter = require('./routes/productos');

const app = express();
const PORT = process.env.PORT || 3000;

// Middleware para parsear JSON
app.use(express.json());

// Middleware para parsear URL-encoded data
app.use(express.urlencoded({ extended: true }));

// CORS basico (para que el frontend pueda hacer peticiones)
app.use((req, res, next) => {
  res.header('Access-Control-Allow-Origin', '*');
  res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
  res.header('Access-Control-Allow-Headers', 'Content-Type');
  next();
});

// Rutas
app.use('/api/productos', productosRouter);

// Ruta raiz
app.get('/', (req, res) => {
  res.json({
    mensaje: 'API REST con Node.js y Express',
    version: '1.0.0',
    endpoints: ['/api/productos']
  });
});

// Manejo de rutas no encontradas
app.use((req, res) => {
  res.status(404).json({ error: 'Ruta no encontrada' });
});

// Middleware de manejo de errores
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({ error: 'Error interno del servidor' });
});

app.listen(PORT, () => {
  console.log('Servidor corriendo en http://localhost:' + PORT);
});

module.exports = app;

Paso 5: Crear los datos de prueba

// src/data/productos.js
let productos = [
  { id: 1, nombre: 'Curso Node.js', precio: 49.99, categoria: 'Programacion', disponible: true },
  { id: 2, nombre: 'Libro Express.js', precio: 24.99, categoria: 'Libros', disponible: true },
  { id: 3, nombre: 'Teclado mecanico', precio: 89.99, categoria: 'Hardware', disponible: false },
];

let nextId = 4;

module.exports = { productos, getNextId: () => nextId++ };

Paso 6: Crear el controlador

// src/controllers/productosController.js
const { productos, getNextId } = require('../data/productos');

// GET /api/productos - Obtener todos los productos
const obtenerTodos = (req, res) => {
  const { categoria, disponible } = req.query;
  let resultado = [...productos];

  if (categoria) {
    resultado = resultado.filter(p => 
      p.categoria.toLowerCase() === categoria.toLowerCase()
    );
  }

  if (disponible !== undefined) {
    resultado = resultado.filter(p => p.disponible === (disponible === 'true'));
  }

  res.json({
    ok: true,
    total: resultado.length,
    datos: resultado
  });
};

// GET /api/productos/:id - Obtener un producto por ID
const obtenerUno = (req, res) => {
  const id = parseInt(req.params.id);
  const producto = productos.find(p => p.id === id);

  if (!producto) {
    return res.status(404).json({ ok: false, error: 'Producto no encontrado' });
  }

  res.json({ ok: true, datos: producto });
};

// POST /api/productos - Crear un nuevo producto
const crear = (req, res) => {
  const { nombre, precio, categoria, disponible = true } = req.body;

  if (!nombre || !precio || !categoria) {
    return res.status(400).json({ 
      ok: false, 
      error: 'Faltan campos obligatorios: nombre, precio, categoria' 
    });
  }

  const nuevoProd = {
    id: getNextId(),
    nombre,
    precio: parseFloat(precio),
    categoria,
    disponible
  };

  productos.push(nuevoProd);
  res.status(201).json({ ok: true, datos: nuevoProd });
};

// PUT /api/productos/:id - Actualizar un producto
const actualizar = (req, res) => {
  const id = parseInt(req.params.id);
  const index = productos.findIndex(p => p.id === id);

  if (index === -1) {
    return res.status(404).json({ ok: false, error: 'Producto no encontrado' });
  }

  productos[index] = { ...productos[index], ...req.body, id };
  res.json({ ok: true, datos: productos[index] });
};

// DELETE /api/productos/:id - Eliminar un producto
const eliminar = (req, res) => {
  const id = parseInt(req.params.id);
  const index = productos.findIndex(p => p.id === id);

  if (index === -1) {
    return res.status(404).json({ ok: false, error: 'Producto no encontrado' });
  }

  const eliminado = productos.splice(index, 1)[0];
  res.json({ ok: true, mensaje: 'Producto eliminado', datos: eliminado });
};

module.exports = { obtenerTodos, obtenerUno, crear, actualizar, eliminar };

Paso 7: Definir las rutas

// src/routes/productos.js
const express = require('express');
const router = express.Router();
const { obtenerTodos, obtenerUno, crear, actualizar, eliminar } = require('../controllers/productosController');

router.get('/', obtenerTodos);       // GET /api/productos
router.get('/:id', obtenerUno);      // GET /api/productos/:id
router.post('/', crear);             // POST /api/productos
router.put('/:id', actualizar);      // PUT /api/productos/:id
router.delete('/:id', eliminar);     // DELETE /api/productos/:id

module.exports = router;

Probar la API con ejemplos reales

Inicia el servidor con node src/app.js y prueba los endpoints. Puedes usar herramientas como Postman, Insomnia o simplemente curl desde la terminal:

Obtener todos los productos

curl http://localhost:3000/api/productos

# Respuesta:
{
  "ok": true,
  "total": 3,
  "datos": [
    { "id": 1, "nombre": "Curso Node.js", "precio": 49.99, ... },
    ...
  ]
}

Crear un nuevo producto

curl -X POST http://localhost:3000/api/productos   -H "Content-Type: application/json"   -d '{"nombre":"Mouse inalambrico","precio":35.99,"categoria":"Hardware"}'

Filtrar por categoria

curl "http://localhost:3000/api/productos?categoria=Hardware"
curl "http://localhost:3000/api/productos?disponible=true"

Buenas practicas para APIs REST con Node.js

Ahora que ya tienes una API funcionando, aqui van algunas buenas practicas que deberias aplicar en proyectos reales:

1. Usa variables de entorno: Nunca pongas credenciales o configuraciones sensibles directamente en el codigo. Usa el paquete dotenv para cargar variables desde un archivo .env.
2. Valida siempre la entrada: Usa librerias como joi o express-validator para validar los datos que recibes en las peticiones.
3. Maneja los errores correctamente: Implementa un middleware de manejo de errores centralizado. Nunca dejes errores sin capturar.
4. Usa un ORM o query builder: Para trabajar con bases de datos reales, usa Prisma, Sequelize o TypeORM en lugar de queries SQL directas.
5. Documenta tu API: Usa Swagger/OpenAPI para documentar tus endpoints. Hay librerias como swagger-ui-express que lo hacen muy facil.
6. Implementa autenticacion: Para APIs publicas o privadas, usa JWT (JSON Web Tokens) con el paquete jsonwebtoken.
7. Configura CORS correctamente: No uses * en produccion. Especifica exactamente que dominios pueden acceder a tu API.

Modulos de Node.js que debes conocer

Node.js incluye muchos modulos utiles de serie (sin necesidad de instalar nada). Estos son los mas importantes:

Modulo	Para que sirve	Ejemplo de uso
fs	Sistema de archivos	Leer, escribir y manipular archivos
path	Rutas de archivos	Construir rutas de forma compatible
http	Servidor HTTP	Crear servidores web basicos
crypto	Criptografia	Hash de contrasenas, tokens
events	Eventos	Crear sistemas basados en eventos
stream	Flujos de datos	Procesar datos grandes eficientemente
child_process	Procesos hijo	Ejecutar comandos del sistema

Node.js vs Bun: cual usar en 2026

En 2026, Bun ha madurado considerablemente como alternativa a Node.js. Bun es un runtime de JavaScript todo-en-uno que incluye un gestor de paquetes, un bundler y un test runner. Es significativamente mas rapido que Node.js en muchos benchmarks. Sin embargo, Node.js sigue siendo la opcion mas estable, con el ecosistema mas grande y la mayor compatibilidad. Para proyectos de produccion, especialmente si trabajas en equipo o en una empresa, Node.js sigue siendo la eleccion mas segura en 2026.

Proximos pasos: como seguir aprendiendo Node.js

Ya tienes una base solida. Aqui tienes el camino recomendado para continuar:

1. Conecta una base de datos: Aprende a usar MongoDB con Mongoose o PostgreSQL con Prisma en tu API Express.
2. Aprende autenticacion: Implementa JWT para proteger tus endpoints.
3. Explora frameworks mas opinionados: Una vez domines Express, prueba NestJS (que usa TypeScript y tiene una estructura similar a Angular) o Fastify (mas rapido que Express).
4. Despliega tu API: Aprende a desplegar aplicaciones Node.js en servicios como Railway, Render, Fly.io o AWS.
5. Testing: Aprende a escribir tests para tus APIs con Vitest o Jest y supertest.

Conclusion

Node.js es una tecnologia imprescindible para cualquier desarrollador web en 2026. Su capacidad de usar JavaScript tanto en el frontend como en el backend, combinada con el inmenso ecosistema de npm, lo convierten en una herramienta extremadamente versatil y poderosa. Con Express, puedes crear APIs REST robustas y bien estructuradas en muy poco tiempo.

El camino de aprendizaje puede parecer largo al principio, pero si ya conoces JavaScript, el salto a Node.js es sorprendentemente natural. Empieza con el proyecto de esta guia, expande con una base de datos real y poco a poco iras construyendo aplicaciones cada vez mas complejas y profesionales.

Si tienes alguna duda sobre Node.js o Express, dejala en los comentarios. Y si este articulo te ha resultado util, no olvides compartirlo con otros desarrolladores que quieran aprender Node.js. Eso es exactamente para lo que existe TuRinconDev: para que aprendas a programar de verdad, sin rodeos.