FastAPI en Python: qué es, para qué sirve y cómo empezar paso a paso
FastAPI en Python: primeras impresiones y puesta en marcha 🚀
Llevo un tiempo trasteando con Python más allá de scripts sueltos, y tarde o temprano acabas llegando a un punto: necesitas montar una API.
Ahí es donde aparece FastAPI, un framework que últimamente no deja de salir en conversaciones, comparativas y ofertas de empleo.
👉 Documentación oficial: https://fastapi.tiangolo.com/
👉 Web del proyecto: https://fastapi.tiangolo.com/
¿Qué es FastAPI? 🤔
FastAPI es un framework moderno para construir APIs con Python basado en estándares como ASGI1 y aprovechando al máximo los type hints.
Su objetivo es bastante claro: 👉 hacer APIs rápidas, fáciles de escribir y bien documentadas desde el minuto uno.
Y lo curioso es que cumple las tres cosas.
1Asynchronous Server Gateway Interface.
Es una especificación (una especie de “contrato”) que define cómo se comunican un servidor web y una aplicación Python, especialmente cuando hay procesos asíncronos de por medio.
La idea rápida 🧠 WSGI → modelo antiguo (sincrónico) ASGI → modelo moderno (asíncrono)
ASGI es, básicamente, la evolución necesaria para poder manejar:
- múltiples peticiones al mismo tiempo ⚡
- websockets (tiempo real)
- tareas no bloqueantes
¿Para qué sirve realmente?
El caso de uso más habitual es este:
- Crear APIs REST
- Backend para aplicaciones web (React, Vue, etc.)
- Microservicios
- Prototipos rápidos que luego pueden escalar
Un ejemplo muy típico: tienes una app en React y necesitas un backend que gestione usuarios, datos, autenticación… FastAPI encaja perfectamente ahí.
¿Por qué tanta gente habla de FastAPI? ⚡
Después de probarlo, se entienden varias cosas:
1. Es muy rápido (de verdad)
Está basado en Starlette y Pydantic, y funciona sobre ASGI, lo que permite concurrencia eficiente.
2. Usa tipado de Python (y lo aprovecha)
Esto cambia bastante la experiencia.
1
2
3
4
5
6
7
from fastapi import FastAPI
app = FastAPI()
@app.get("/items/{item_id}")
def read_item(item_id: int):
return {"item_id": item_id}
Solo con esto:
- Valida que
item_idsea un entero - Genera documentación automática
- Te da autocompletado en el editor
3. Documentación automática (esto es una locura)
Nada más levantar el servidor tienes:
/docs→ Swagger UI/redoc→ Documentación alternativa
No tienes que escribir nada extra. Sale directamente del código.
¿En qué mejora la programación con Python? 🧠
Aquí es donde más me ha llamado la atención.
Código más claro
El uso de tipos hace que todo sea más explícito:
1
2
3
4
5
6
7
from fastapi import FastAPI
app = FastAPI()
@app.get("/users/")
def get_users(limit: int = 10):
return {"limit": limit}
Ya sabes qué espera la función sin leer documentación adicional.
Validación automática
Con Pydantic puedes definir esquemas así:
1
2
3
4
5
from pydantic import BaseModel
class User(BaseModel):
name: str
age: int
Y FastAPI:
- Valida datos de entrada
- Devuelve errores claros si algo falla
- Convierte tipos automáticamente
Menos código repetitivo
Comparado con otros frameworks, hay menos “pegamento” que escribir.
Instalación paso a paso 🛠️
Aquí no hay mucha historia, pero lo dejo anotado.
1. Crear entorno virtual (recomendado)
1
2
3
python -m venv venv
source venv/bin/activate # Linux / Mac
venv\Scripts\activate # Windows
2. Instalar FastAPI y servidor
1
pip install fastapi uvicorn
3. Crear tu primera app
Archivo main.py:
1
2
3
4
5
6
7
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"mensaje": "Hola mundo"}
4. Ejecutar el servidor
1
uvicorn main:app --reload
Y listo:
Un ejemplo un poco más real 🧪
Algo típico: recibir datos en POST.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Producto(BaseModel):
nombre: str
precio: float
@app.post("/productos/")
def crear_producto(producto: Producto):
return {
"mensaje": "Producto creado",
"producto": producto
}
Aquí ya estás:
- Recibiendo JSON
- Validando datos
- Devolviendo respuesta estructurada
Sin apenas esfuerzo.
Sensaciones después de probarlo
La curva de entrada es muy suave si ya conoces Python.
Lo que más se nota:
- Menos tiempo configurando cosas
- Más tiempo construyendo lógica real
- Código más limpio
Y sobre todo, la sensación de que todo “encaja” bastante bien desde el principio.
Comparativa rápida mental 🧩
Sin entrar en guerras:
- Flask → minimalista, más manual
- Django → completo, más pesado
- FastAPI → equilibrio moderno, rápido y tipado
Si estás empezando a hacer backend con Python o vienes de montar APIs con otras herramientas, merece bastante la pena darle una vuelta.
❓ FAQ
¿Qué es FastAPI en Python?
FastAPI es un framework moderno para crear APIs con Python de forma rápida, eficiente y con validación automática de datos usando type hints.
¿Para qué sirve FastAPI?
Se utiliza principalmente para desarrollar APIs REST y servicios backend de alto rendimiento, especialmente en aplicaciones modernas que requieren rapidez y escalabilidad.
¿Es mejor FastAPI que Flask o Django?
Depende del caso. FastAPI destaca por su velocidad, tipado y documentación automática, mientras que Flask es más simple y Django más completo como framework full-stack.
¿Cómo se instala FastAPI?
Se instala con pip usando el comando 'pip install fastapi uvicorn' y se ejecuta con un servidor ASGI como Uvicorn.