Si llevas un tiempo aprendiendo Python y quieres dar el siguiente paso hacia algo más profesional, crear una API es uno de los mejores proyectos prácticos que puedes hacer. No porque sea complicado, sino porque te enseña cómo funcionan realmente las aplicaciones web modernas y te abre la puerta al desarrollo backend. En este tutorial vamos a construir una API funcional desde cero usando FastAPI, la librería más moderna y sencilla disponible hoy para Python.
¿Qué es una API y para qué sirve?
API significa Application Programming Interface, o Interfaz de Programación de Aplicaciones. En términos simples, es un sistema que permite que dos programas se comuniquen entre sí. Cuando abres una app del clima en tu celular y te muestra la temperatura, esa app no tiene los datos almacenados — los pide a través de una API a un servidor externo. Cuando inicias sesión en una página web con tu cuenta de Google, hay una API en medio de ese proceso.
En el desarrollo web moderno, las APIs son el puente entre el frontend (lo que el usuario ve) y el backend (donde viven los datos y la lógica). Aprender a construir una es una habilidad muy demandada en el mercado laboral.
¿Por qué FastAPI y no Flask o Django?
Python tiene varias opciones para crear APIs: Flask, Django REST Framework y FastAPI son las más populares. FastAPI tiene tres ventajas claras para un principiante en 2026:
- Es extremadamente rápida de configurar.
- Genera documentación interactiva automáticamente, sin escribir una sola línea extra.
- Usa tipado de Python moderno que hace el código más claro y fácil de entender.
Flask sigue siendo una opción válida, pero FastAPI se ha convertido en el estándar para proyectos nuevos.
Requisitos previos
Antes de empezar necesitas tener Python 3.8 o superior instalado en tu computadora y conocimientos básicos de Python: variables, funciones y algo de manejo de diccionarios. Si acabas de instalar Python, también necesitas pip, que viene incluido por defecto desde Python 3.4.
Paso 1 — Instalar FastAPI y Uvicorn
Abre la terminal (o la terminal integrada de VS Code con Ctrl + ñ) y ejecuta:
pip install fastapi uvicorn
FastAPI es el framework que vamos a usar para construir la API. Uvicorn es el servidor que la va a ejecutar. Los dos son necesarios.
Paso 2 — Crear el archivo principal
Crea una carpeta nueva llamada mi_api y dentro de ella un archivo llamado main.py. Abre ese archivo en VS Code y escribe lo siguiente:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def inicio():
return {"mensaje": "¡Hola! Tu API está funcionando."}
Vamos a entender qué hace cada parte:
from fastapi import FastAPI— importa la librería.app = FastAPI()— crea la instancia de tu aplicación.@app.get("/")— le dice a FastAPI que cuando alguien haga una petición GET a la ruta/, ejecute la función de abajo.return {"mensaje": "..."}— devuelve un objeto JSON como respuesta.
Paso 3 — Ejecutar la API
En la terminal, asegúrate de estar dentro de la carpeta mi_api y ejecuta:
uvicorn main:app --reload
El flag --reload hace que el servidor se reinicie automáticamente cada vez que guardas un cambio. Verás este mensaje en la terminal:
INFO: Uvicorn running on http://127.0.0.1:8000
Abre tu navegador y entra a http://127.0.0.1:8000. Verás:
{"mensaje": "¡Hola! Tu API está funcionando."}
Tu primera API está viva.
Paso 4 — La documentación automática
Sin hacer nada adicional, entra a http://127.0.0.1:8000/docs en tu navegador. Verás una interfaz interactiva generada automáticamente que muestra todos los endpoints de tu API y te permite probarlos directamente desde el navegador. Esto se llama Swagger UI y FastAPI lo genera solo, sin que tengas que configurar nada.
Tip: La documentación en /docs es una de las características más valoradas de FastAPI en equipos profesionales. Te permite probar cada endpoint sin necesidad de herramientas externas como Postman.
Paso 5 — Agregar más rutas: API de tareas
Una API útil tiene múltiples rutas. Vamos a construir una API sencilla que maneje una lista de tareas. Reemplaza todo el contenido de main.py con esto:
from fastapi import FastAPI
app = FastAPI()
tareas = [
{"id": 1, "titulo": "Aprender Python", "completada": False},
{"id": 2, "titulo": "Crear una API", "completada": False},
{"id": 3, "titulo": "Publicar en GitHub", "completada": False},
]
@app.get("/")
def inicio():
return {"mensaje": "API de tareas funcionando"}
@app.get("/tareas")
def obtener_tareas():
return tareas
@app.get("/tareas/{tarea_id}")
def obtener_tarea(tarea_id: int):
for tarea in tareas:
if tarea["id"] == tarea_id:
return tarea
return {"error": "Tarea no encontrada"}
@app.post("/tareas")
def crear_tarea(titulo: str):
nueva_tarea = {
"id": len(tareas) + 1,
"titulo": titulo,
"completada": False
}
tareas.append(nueva_tarea)
return nueva_tarea
Con este código tienes cuatro endpoints funcionando:
GET /— devuelve un mensaje de bienvenida.GET /tareas— devuelve la lista completa de tareas.GET /tareas/{tarea_id}— devuelve una tarea específica por su ID.POST /tareas— crea una nueva tarea recibiendo el título como parámetro.
Paso 6 — Probar los endpoints
Desde la documentación en /docs puedes hacer clic en cualquier endpoint, luego en Try it out y ejecutarlo directamente. Para probar el endpoint POST de crear tarea, escribe un título en el campo y haz clic en Execute. Verás la respuesta en tiempo real.
También puedes probar los endpoints GET directamente desde el navegador:
http://127.0.0.1:8000/tareashttp://127.0.0.1:8000/tareas/1
Una nota importante sobre los datos
Importante: En este tutorial los datos viven en una lista de Python en memoria, lo que significa que se reinician cada vez que reinicias el servidor. En una API real los datos se guardan en una base de datos como PostgreSQL, MySQL o SQLite. Conectar FastAPI a una base de datos es el siguiente paso natural, y lo cubriremos en un próximo tutorial.
¿Y ahora qué?
Con lo que aprendiste hoy puedes construir APIs básicas que reciben peticiones y devuelven datos en formato JSON. Eso ya es suficiente para conectar una API a un frontend simple hecho con HTML y JavaScript, o para practicar conceptos de backend que te van a servir en cualquier trabajo de desarrollo.
Los próximos pasos naturales son:
- Aprender a validar los datos que recibe tu API usando los modelos de Pydantic que FastAPI incluye.
- Conectar la API a una base de datos real con SQLite o PostgreSQL.
- Agregar autenticación básica para proteger ciertos endpoints.
Todo eso lo iremos cubriendo en SystemsBM en próximas entregas. Si te quedó alguna duda sobre este tutorial, déjala en los comentarios.
Publicar un comentario