¿Qué es FastAPI?

Descripción de la cápsula

FastAPI es un framework moderno para construir APIs REST en Python. Creado por Sebastián Ramírez (tiangolo), combina alto rendimiento, tipado estático, validación automática y documentación integrada. Si vienes de Flask o Django, descubrirás que FastAPI adopta un enfoque diferente: menos configuración manual, más convenciones inteligentes derivadas de los type hints de Python.

Esta cápsula responde las preguntas clave antes de tocar una línea de código: qué es FastAPI, por qué elegirlo frente a alternativas, qué características lo destacan, quién lo usa en producción, y cómo encaja en el ecosistema Python para APIs.

Definición: ¿Qué es FastAPI?

FastAPI es un framework web moderno y de alto rendimiento para construir APIs con Python 3.8+. Está construido sobre estándares abiertos: OpenAPI para documentación y ASGI para el protocolo de servidor.

En una frase: FastAPI es el framework que hace que escribir APIs REST en Python sea rápido, seguro y con documentación automática.

Origen del nombre

"Fast" hace referencia a dos cosas: (1) alto rendimiento en ejecución, y (2) velocidad de desarrollo. "API" indica su enfoque principal. No es un framework para servir páginas HTML complejas con templates — está diseñado para exponer endpoints que retornan datos (típicamente JSON).

Características principales

FastAPI vs Flask vs Django

Si conoces Flask o Django, esta comparación te sitúa:

¿Cuándo elegir FastAPI?

• ✅ Construyes APIs REST o GraphQL como producto principal
• ✅ Quieres documentación automática que refleje tu código
• ✅ Usas o quieres usar type hints en Python
• ✅ Necesitas alto rendimiento (muchos requests concurrentes)
• ✅ Tu stack incluye async/await (bases de datos async, HTTP cliente async)

¿Cuándo considerar Flask o Django?

• Flask: prototipos muy rápidos, apps pequeñas, más control manual
• Django: aplicaciones completas con panel de administración, ORM complejo, auth incluido

Tabla de decisión rápida

Características clave en detalle

1. Async y type hints

FastAPI está diseñado desde cero para aprovechar las capacidades modernas de Python:

# Ejemplo mínimo — los type hints activan validación y docs
from fastapi import FastAPI

app = FastAPI()

@app.get("/items/{item_id}")
def get_item(item_id: int):  # ← El type hint int valida automáticamente
    return {"item_id": item_id}

Si alguien llama /items/abc, FastAPI retorna un error 422 con un mensaje claro — sin escribir validación manual.

2. Validación automática con Pydantic

FastAPI usa Pydantic para validar requests y serializar responses. Pydantic está integrado en el core del framework:

• Request body: Define un modelo Pydantic y FastAPI valida el JSON entrante
• Path/query params: Los type hints (int, str, Optional[int]) activan validación
• Response: Puedes declarar modelos de respuesta para documentación precisa

En el Módulo 4 trabajarás con Pydantic en profundidad. Por ahora basta saber que los type hints simples (int, str) ya activan validación básica sin modelos.

3. Documentación automática (OpenAPI)

Cada endpoint que defines aparece automáticamente en:

• /docs — Swagger UI interactivo (puedes probar endpoints desde el navegador)
• /redoc — ReDoc (documentación de referencia)
• /openapi.json — Schema OpenAPI en JSON

No escribes documentación separada. El código es la documentación.

4. Estándares abiertos

FastAPI se basa en:

• OpenAPI 3.1 — Estándar de industria para describir APIs
• JSON Schema — Para validación de datos
• ASGI — Protocolo asíncrono para aplicaciones web en Python

Ecosistema: uvicorn, Pydantic, Starlette

FastAPI no trabaja solo. Su stack típico:

Request HTTP → uvicorn → Starlette → FastAPI → tu código

• uvicorn: Lo instalarás explícitamente (pip install uvicorn[standard])
• Pydantic: Viene con FastAPI
• Starlette: Dependencia interna de FastAPI, no lo configuras directamente

¿Quién usa FastAPI?

FastAPI es usado en producción por empresas y proyectos de todo tamaño. Algunos ejemplos públicos:

• Microsoft — Documentación oficial menciona uso interno
• Uber — APIs internas
• Netflix — Herramientas internas
• Explosion (creadores de spaCy) — APIs de NLP
• Proyectos open source — Muchos repos en GitHub adoptan FastAPI para APIs

Su adopción ha crecido rápidamente desde su lanzamiento en 2018, especialmente en el espacio de machine learning y APIs de alto rendimiento.

Por qué las empresas lo adoptan

Las razones típicas que citan equipos que migraron a FastAPI:

1. Menos tiempo en documentación: La documentación automática se mantiene sincronizada con el código. No hay que actualizar Postman collections o Confluence manualmente.
2. Validación desde el contrato: Los type hints definen el contrato de la API. Si cambias un tipo, los tests y la documentación reflejan el cambio automáticamente.
3. Rendimiento sin sacrificar DX: No tienes que elegir entre velocidad de desarrollo y velocidad de ejecución. FastAPI ofrece ambos.
4. Estandarización: OpenAPI permite generar clientes en otros lenguajes (TypeScript, Go) desde el schema. Útil en equipos multi-stack.

Práctica: Comparar con un ejemplo mínimo

Para sentir la diferencia, aquí está el mismo endpoint en los tres frameworks:

Flask

from flask import Flask, jsonify

app = Flask(__name__)

@app.route("/items/<int:item_id>")
def get_item(item_id):
    return jsonify({"item_id": item_id})

Django (con Django REST Framework)

# views.py
from rest_framework.decorators import api_view
from rest_framework.response import Response

@api_view(['GET'])
def get_item(request, item_id):
    return Response({"item_id": item_id})

FastAPI

from fastapi import FastAPI

app = FastAPI()

@app.get("/items/{item_id}")
def get_item(item_id: int):
    return {"item_id": item_id}

Diferencias notables:

• FastAPI no requiere jsonify ni Response — retornar un dict es suficiente
• El type hint int en FastAPI garantiza validación; en Flask el int: en la ruta convierte pero no documenta
• FastAPI genera documentación automática; Flask y DRF requieren configuración adicional

Cantidad de código

Flask: 7 líneas (sin contar imports). Django/DRF: más líneas por el boilerplate de views y URLs. FastAPI: 5 líneas en el endpoint, y además obtienes validación y documentación sin código extra.

Qué hace FastAPI por ti automáticamente

Cuando defines def get_item(item_id: int):

1. Validación: Si llega "abc", retorna 422 con mensaje claro
2. Conversión: "42" se convierte a int antes de llegar a la función
3. Documentación: En /docs aparece que item_id es integer, obligatorio
4. Serialización: El return se convierte a JSON con Content-Type correcto

Todo eso sin una línea de código adicional.

Ejemplo: Validación automática en acción

Supón que defines:

@app.get("/users/{user_id}")
def get_user(user_id: int):
    return {"user_id": user_id}

Llamadas válidas e inválidas:

La validación de tipo evita que datos incorrectos lleguen a tu lógica. El mensaje de error 422 incluye qué parámetro falló y por qué.

Integración con el ecosistema Python

FastAPI se integra bien con herramientas que ya conoces:

En el path Backend Python Developer usarás varias de estas en combinación con FastAPI.

Cuándo NO usar FastAPI

FastAPI no es la herramienta para todo. Considera alternativas cuando:

• Necesitas un panel de administración listo (Django Admin)
• Tu equipo no usa type hints y no quiere adoptarlos
• El proyecto es un monolito tradicional con muchas páginas HTML servidas por el backend
• Requieres un ecosistema de plugins muy maduro (Django tiene más añños)

Para APIs puras, microservicios y aplicaciones modernas, FastAPI suele ser la mejor opción en Python.

Troubleshooting conceptual

"¿FastAPI reemplaza a Django?"

No. Son herramientas para problemas distintos. Django es un framework full-stack (HTML, ORM, admin, auth). FastAPI es para APIs. Puedes tener un backend Django que expone una API con DRF, o un microservicio puro con FastAPI.

"¿Necesito saber async para empezar?"

No. Puedes escribir endpoints síncronos (def) desde el inicio. FastAPI los ejecuta en un thread pool. Cuando integres bases de datos async, aprenderás async def.

"¿FastAPI es solo para APIs o también para servir HTML?"

FastAPI puede servir HTML y archivos estáticos, pero está optimizado para APIs (JSON). Para aplicaciones web con muchas páginas HTML, Django o Flask suelen ser más cómodos.

"¿Qué versión de Python necesito?"

Python 3.8+. Se recomienda 3.9 o superior para mejor soporte de type hints.

Historia y filosofía

FastAPI fue lanzado en 2018 por Sebastián Ramírez. Su filosofía se resume en tres pilares:

1. Performance: Basado en Starlette (uno de los frameworks Python más rápidos) y Pydantic (validación en Rust)
2. Developer experience: Documentación automática, validación con type hints, menos código repetitivo
3. Standards-based: OpenAPI, JSON Schema, OAuth2 — herramientas estándar que integran con el ecosistema

A diferencia de frameworks que priorizan flexibilidad máxima (Flask) o convención sobre configuración (Django), FastAPI prioriza menos código manual, más inferencia inteligente a partir de lo que ya escribes.

Benchmarks: ¿Qué tan rápido es?

Benchmarks públicos (como TechEmpower) sitúan a FastAPI entre los frameworks Python más rápidos, a menudo superando a Flask y Django por amplio margen. La razón: ASGI maneja múltiples requests concurrentes en un solo proceso, y el código está optimizado para I/O asíncrono.

Para APIs que hacen muchas llamadas a bases de datos o servicios externos, la diferencia puede ser significativa. Para APIs que retornan datos en memoria, cualquier framework moderno suele ser suficiente.

Preguntas frecuentes de principiantes

"¿Necesito saber JavaScript o frontend?"
No. FastAPI es para backends. Tu API retorna JSON. Otros (React, Vue, móvil) consumen ese JSON. Puedes desarrollar y probar la API sin tocar frontend.

"¿Puedo usar FastAPI con base de datos?"
Sí. En guías posteriores integrarás PostgreSQL con SQLAlchemy. FastAPI no incluye ORM; se combina con herramientas existentes.

"¿Es difícil migrar de Flask a FastAPI?"
Depende del tamaño. APIs pequeñas: unas horas. Proyectos grandes: días o semanas. Los conceptos son similares (rutas, request/response); la sintaxis cambia.

"¿FastAPI tiene auth incluido?"
Incluye soporte para OAuth2 y JWT en el paquete fastapi.security. La implementación (base de datos de usuarios, etc.) la haces tú o usas librerías. Se cubre en la guía de Authentication.

"¿Qué pasa con las websockets?"
FastAPI soporta WebSockets nativamente. Se cubre en módulos avanzados. Para empezar, los endpoints HTTP GET/POST son suficientes.

Ejercicios

Ejercicio 1: Tabla comparativa (Fácil)

Crea una tabla comparando FastAPI, Flask y Django en 4 aspectos que te importen para elegir un framework para un proyecto de API REST. Usa tus propias palabras.

Ejercicio 2: ¿FastAPI o Flask? (Medio)

Tienes que elegir framework para: (a) un API de microservicio que procesa imágenes con ML, (b) un prototipo rápido de CRUD en 2 horas. ¿Qué elegirías en cada caso y por qué?

Ejercicio 3: Ecosistema (Fácil)

¿Cuál de estos componentes instalas explícitamente con pip para un proyecto FastAPI básico: FastAPI, uvicorn, Pydantic, Starlette? ¿Cuáles vienen incluidos?

pip install fastapi "uvicorn[standard]"

Ejercicio 4: Type hints y validación (Medio)

En el ejemplo @app.get("/items/{item_id}") con def get_item(item_id: int), ¿qué pasa si un cliente llama a /items/abc? ¿Y a /items/42? Explica el comportamiento de FastAPI en cada caso.

Ejercicio 5: Estándares (Fácil)

FastAPI usa OpenAPI y ASGI. Busca qué significa cada uno en una frase. ¿Por qué importa usar estándares en vez de formatos propietarios?

Ejercicio 5b: Simular validación (Medio)

Sin ejecutar código, predice: si tienes @app.get("/items/{id}") con def get_item(id: int), y un cliente envía GET /items/xyz, ¿qué status code retornará FastAPI? ¿Se ejecutará la función? ¿Qué verá el cliente en el body de la respuesta?

Ejercicio 6: Argumentar la elección (Medio)

Escribir un párrafo (5-7 oraciones) justificando por qué FastAPI es una buena elección para el path Backend Python Developer. Incluir al menos 3 razones concretas.

Resumen de la cápsula: Lo esencial

Antes de pasar a la instalación, asegúrate de tener claro:

1. Qué es FastAPI: Framework para APIs REST en Python, alto rendimiento, docs automáticas.
2. Por qué frente a Flask/Django: Mejor para APIs puras; Flask para prototipos; Django para apps completas con admin.
3. Ecosistema: FastAPI + uvicorn + Pydantic + Starlette. Instalas FastAPI y uvicorn; el resto viene incluido.
4. Type hints: No son opcionales en FastAPI — activan validación y documentación. Si ya usas Python con tipos, te sentirás en casa.
5. Estándares: OpenAPI y ASGI permiten integrar con herramientas de terceros y generar clientes en otros lenguajes.

La siguiente cápsula es práctica: crearás el proyecto, instalarás dependencias y escribirás tu primer main.py.

Resumen visual: Stack completo

Cliente (navegador, Postman, curl)
    ↓ HTTP
uvicorn (ASGI server) — escucha en puerto 8000
    ↓ pasa el request
FastAPI (framework)
    ↓ routing + validación
Tu endpoint (función Python)
    ↓ return dict/list
FastAPI (serialización a JSON)
    ↓
uvicorn → HTTP response al cliente

Mientras desarrollas, usarás /docs para probar. En producción, uvicorn (o Gunicorn+uvicorn) sirve la app. FastAPI es la capa que conecta HTTP con tu lógica de negocio.

Resumen

• ✅ FastAPI es un framework moderno para APIs REST en Python, con alto rendimiento y documentación automática
• ✅ Destaca frente a Flask/Django en: validación integrada, docs automáticas, async nativo
• ✅ Usa type hints, Pydantic, uvicorn y Starlette en su ecosistema
• ✅ Es ideal para APIs modernas, microservicios y proyectos que priorizan velocidad de desarrollo y rendimiento
• ✅ Empresas como Microsoft, Uber y Netflix lo usan en producción

Próxima cápsula: Instalación y Estructura — configurarás tu entorno y crearás la estructura base del proyecto.

Mapa mental: FastAPI en una página

FastAPI
├── Qué es: Framework para APIs REST en Python
├── Por qué: Alto rendimiento, docs automáticas, validación con type hints
├── Cuándo: APIs puras, microservicios, alto tráfico
├── Cuándo no: Apps con admin listo (Django), equipos sin type hints
├── Ecosistema: uvicorn (servidor) + Pydantic (validación) + Starlette (base)
├── Estándares: OpenAPI (docs) + ASGI (protocolo)
└── Quién lo usa: Microsoft, Uber, Netflix, startups, proyectos open source

Usa este mapa como referencia cuando tengas que explicar o recordar por qué elegiste FastAPI.

Transición a la siguiente cápsula

En la Cápsula 03 (Instalación y Estructura) pondrás en práctica todo lo conceptual de esta cápsula:

• Crearás un virtual environment
• Instalarás fastapi y uvicorn[standard]
• Generarás requirements.txt
• Crearás la estructura app/main.py
• Escribirás el primer endpoint que retorna {"message": "FastAPI is running"}

La teoría de esta cápsula te da contexto. La práctica de la siguiente te da un proyecto funcional. No necesitas memorizar tablas comparativas — con el uso te quedarán claras las diferencias entre FastAPI y otras opciones.

Resumen ejecutivo (30 segundos)

• FastAPI = framework Python para APIs REST, alto rendimiento, docs automáticas.
• Ventaja principal: validación + documentación desde type hints, sin código extra.
• Stack: FastAPI + uvicorn + Pydantic (incluido).
• Elegir FastAPI cuando: API es el producto, quieres docs automáticas, alto tráfico.
• Elegir Flask/Django cuando: prototipo mínimo, app completa con admin.

Próximo paso

Pasa a la Cápsula 03 para instalar FastAPI, configurar el proyecto y ejecutar tu primer endpoint. Todo lo conceptual de esta cápsula cobrará sentido cuando veas el código en acción.

Tres ideas para llevarte

1. Menos código, más inferencia: FastAPI usa lo que escribes (type hints, nombres) para generar documentación y validación. No duplicas esfuerzo.
2. Estándares > custom: OpenAPI y ASGI significan que tu API habla un idioma que el ecosistema entiende.
3. Developer experience: La combinación de velocidad de desarrollo + velocidad de ejecución hace que FastAPI sea una inversión que paga rápido.

Si vienes de otro framework

• Flask: Los decoradores te resultarán familiares. La diferencia: no usas jsonify; retornas dicts directamente. Los type hints son la novedad principal.
• Django/DRF: FastAPI es más ligero. No hay models, migrations ni admin. Es solo la capa HTTP. La base de datos la integras con SQLAlchemy u otra herramienta.
• Node/Express: La filosofía es similar: menos boilerplate, convenciones inteligentes. FastAPI es a Python lo que Express+TypeScript puede ser a Node, pero con documentación automática incluida.

Requisitos previos (recapitulando)

Para seguir esta guía necesitas: Python 3.8+ (recomendado 3.9+), conocimientos básicos de HTTP y REST (de la REST APIs Guide), y familiaridad con Python (funciones, imports, diccionarios). No necesitas experiencia previa con FastAPI, Flask o Django. Si nunca has usado type hints, los aprenderás sobre la marcha — son más simples de lo que parecen.

Recursos Adicionales

1. FastAPI Official Site - Sitio y documentación oficial
2. FastAPI vs Flask - Blog Post - Comparación oficial con alternativas
3. Pydantic Documentation - Validación y serialización de datos
4. Starlette Documentation - Framework base de FastAPI
5. ASGI Specification - Protocolo que usa FastAPI
6. OpenAPI Specification - Estándar de documentación de APIs

Módulo 1, Cápsula 02 — FastAPI Fundamentals Guide