Cómo crear una API REST desde cero: guía completa con PHP y MySQL
Introducción
Hoy en día, casi todo lo que usamos en internet funciona gracias a APIs.
- apps móviles
- dashboards
- sistemas internos
- ecommerce
- integraciones
- SaaS
- automatizaciones
👉 todo se conecta mediante APIs.
Pero aquí viene el problema:
Mucha gente usa APIs…
pero muy pocos saben construirlas bien desde cero.
Y eso marca una diferencia enorme a nivel profesional.
En este tutorial vas a aprender:
- qué es una API REST realmente
- cómo funciona por dentro
- cómo diseñarla correctamente
- cómo conectarla a MySQL
- cómo estructurar el código
- cómo manejar errores
- cómo hacerla usable y escalable
Y lo más importante:
👉 lo vas a hacer desde cero con PHP y MySQL, sin frameworks pesados, para que entiendas la base real.
🧠 Qué es una API REST
Una API es un intermediario que permite que dos sistemas se comuniquen.
Ejemplo:
- frontend → pide datos
- backend (API) → responde
- base de datos → almacena
👉 La API es el puente.
Qué significa REST
REST no es código, es un estilo de arquitectura.
Se basa en:
- recursos
- URLs claras
- uso correcto de HTTP
Ejemplo:
GET /usuarios GET /usuarios/1 POST /usuarios PUT /usuarios/1 DELETE /usuarios/1
👉 Cada URL representa un recurso.
🌐 Métodos HTTP básicos
Método Uso GET Obtener datos POST Crear PUT Actualizar DELETE Eliminar
🧱 Estructura base de una API en PHP
Vamos a crear algo simple pero real.
Estructura recomendada:
api/ │ ├── config/ │ └── db.php │ ├── controllers/ │ └── usuarios.php │ ├── index.php
🔌 Conexión a MySQL (PDO)
config/db.php
<?php
$host = 'localhost';
$db = 'mi_api';
$user = 'root';
$pass = '';
$charset = 'utf8mb4';
$dsn = "mysql:host=$host;dbname=$db;charset=$charset";
$options = [
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
];
try {
$pdo = new PDO($dsn, $user, $pass, $options);
} catch (PDOException $e) {
http_response_code(500);
echo json_encode(["error" => "Error de conexión"]);
exit;
}
🧭 Router básico (index.php)
<?php
header('Content-Type: application/json');
require 'config/db.php';
$method = $_SERVER['REQUEST_METHOD'];
$uri = explode('/', trim($_SERVER['REQUEST_URI'], '/'));
if ($uri[0] === 'usuarios') {
require 'controllers/usuarios.php';
}
👤 Controlador de usuarios
controllers/usuarios.php
<?php
switch ($method) {
case 'GET':
$stmt = $pdo->query("SELECT * FROM usuarios");
echo json_encode($stmt->fetchAll(PDO::FETCH_ASSOC));
break;
case 'POST':
$data = json_decode(file_get_contents("php://input"), true);
$stmt = $pdo->prepare("INSERT INTO usuarios (nombre, email) VALUES (?, ?)");
$stmt->execute([$data['nombre'], $data['email']]);
echo json_encode(["message" => "Usuario creado"]);
break;
default:
http_response_code(405);
echo json_encode(["error" => "Método no permitido"]);
}
🧪 Probando la API
Puedes usar:
- Postman
- curl
- navegador
Ejemplo con curl:
curl http://localhost/api/usuarios
🧱 Diseño correcto de APIs (muy importante)
Una API bien hecha debe tener:
1. URLs limpias
❌ mal:
/getUsers.php?id=1
✅ bien:
/usuarios/1
2. Respuestas consistentes
{
"status": "success",
"data": []
}
3. Códigos HTTP correctos
Código Significado 200 OK 201 Creado 400 Error cliente 404 No encontrado 500 Error servidor
⚠️ Manejo de errores
Ejemplo:
if (!$data) {
http_response_code(400);
echo json_encode(["error" => "Datos inválidos"]);
exit;
}
🔐 Seguridad básica
Muy importante:
- validar inputs
- usar prepared statements
- no exponer errores internos
- controlar acceso
🔑 Autenticación (concepto)
No lo implementamos aquí, pero debes saber:
- tokens (JWT)
- API keys
- sesiones
📦 Ejemplo real: conectar con frontend
Frontend hace:
fetch('/api/usuarios')
API responde:
[
{ "id": 1, "nombre": "Irak" }
]
📈 Escalabilidad (nivel pro)
Cuando creces:
- separas lógica en capas
- usas servicios
- agregas cache
- añades rate limiting
- logging
🧠 Errores comunes
❌ mezclar HTML con API
❌ no validar datos
❌ no usar códigos HTTP
❌ rutas mal diseñadas
❌ no estructurar proyecto
💡 Buenas prácticas
- mantener endpoints simples
- documentar
- usar JSON siempre
- separar lógica
- pensar en crecimiento
🧩 Conclusión:
Saber construir APIs desde cero te lleva a otro nivel.
Porque entiendes:
- cómo se conectan sistemas
- cómo fluye la información
- cómo escalar aplicaciones
Y eso es clave en desarrollo moderno.