FastAPI es el framework de Python que más rápido creció entre los equipos de backend que trabajan con inteligencia artificial. Si desarrollás aplicaciones, automatizaciones o integraciones con modelos de lenguaje, saber crear APIs con FastAPI es una de las habilidades más demandadas en el mercado tech de LATAM.

En esta guía aprendés qué es FastAPI, por qué supera a Flask en proyectos modernos y cómo crear tu primera API REST en menos de 30 minutos, incluso si recién empezás con Python.

Qué es FastAPI

FastAPI es un framework moderno para construir APIs web con Python, creado por Sebastián Ramírez. En poco tiempo se convirtió en uno de los proyectos de código abierto más populares del ecosistema Python, con más de 75.000 estrellas en GitHub.

Sus características principales son:

• Velocidad: uno de los frameworks Python más rápidos disponibles, comparable a Go y NodeJS gracias a su arquitectura ASGI.

• Validación automática: usa Pydantic para validar datos de entrada y salida sin configuración adicional.

• Documentación automática: genera Swagger UI y ReDoc de forma automática al correr el servidor.

• Tipado estático: aprovecha los type hints de Python para reducir errores y mejorar la experiencia de desarrollo.

FastAPI vs Flask: ¿cuál elegir?

Flask fue durante años el framework más popular para APIs en Python. Pero FastAPI lo supera en aspectos clave para el desarrollo moderno:

Para proyectos con IA, donde los endpoints pueden llamar a modelos de lenguaje o procesar grandes volúmenes de datos, FastAPI es la opción recomendada por su soporte nativo de operaciones asíncronas.

Cómo instalar FastAPI

Necesitás Python 3.8 o superior. Instalá FastAPI y Uvicorn (servidor ASGI) con un solo comando:

pip install fastapi uvicorn

pip install fastapi uvicorn

pip install fastapi uvicorn

pip install fastapi uvicorn

Si querés trabajar con requests HTTP asíncronos en tus endpoints:

pip install fastapi uvicorn httpx

pip install fastapi uvicorn httpx

pip install fastapi uvicorn httpx

pip install fastapi uvicorn httpx

Tu primera API con FastAPI: guía paso a paso

Paso 1: crear el archivo principal

Creá un archivo llamado main.py con este código:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"mensaje": "Hola desde FastAPI"}

@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"mensaje": "Hola desde FastAPI"}

@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"mensaje": "Hola desde FastAPI"}

@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"mensaje": "Hola desde FastAPI"}

@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

Paso 2: correr el servidor

Desde la terminal, ejecutá:

uvicorn main:app --reload

uvicorn main:app --reload

uvicorn main:app --reload

uvicorn main:app --reload

El flag --reload reinicia el servidor automáticamente cada vez que modificás el código.

Paso 3: explorar la documentación automática

Abrí tu navegador en http://127.0.0.1:8000/docs. Vas a ver la documentación interactiva generada automáticamente (Swagger UI), donde podés probar todos tus endpoints sin escribir una sola línea extra de código.

Validación de datos con Pydantic

Una de las mayores ventajas de FastAPI es la integración nativa con Pydantic. Definís un modelo con tipos y FastAPI valida todo automáticamente:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    nombre: str
    precio: float
    disponible: bool = True

@app.post("/items/")
def create_item(item: Item):
    return {"item": item, "precio_con_iva": item.precio * 1.21}

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    nombre: str
    precio: float
    disponible: bool = True

@app.post("/items/")
def create_item(item: Item):
    return {"item": item, "precio_con_iva": item.precio * 1.21}

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    nombre: str
    precio: float
    disponible: bool = True

@app.post("/items/")
def create_item(item: Item):
    return {"item": item, "precio_con_iva": item.precio * 1.21}

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    nombre: str
    precio: float
    disponible: bool = True

@app.post("/items/")
def create_item(item: Item):
    return {"item": item, "precio_con_iva": item.precio * 1.21}

Si el cliente manda un precio como texto en lugar de número, FastAPI devuelve automáticamente un error de validación con detalles precisos, sin que tengas que escribir ninguna lógica extra.

Conexión a base de datos

Para conectar tu API a una base de datos, la forma más común es usar SQLAlchemy con PostgreSQL (producción) o SQLite (desarrollo). La librería databases permite hacerlo de forma asíncrona, lo cual es clave cuando tu API maneja muchas peticiones simultáneas:

pip install databases sqlalchemy psycopg2-binary

pip install databases sqlalchemy psycopg2-binary

pip install databases sqlalchemy psycopg2-binary

pip install databases sqlalchemy psycopg2-binary

La documentación oficial de FastAPI tiene un tutorial completo sobre bases de datos con soporte asíncrono.

FastAPI y proyectos con IA

FastAPI se convirtió en el estándar para backends de aplicaciones con inteligencia artificial por varias razones concretas:

• Permite servir modelos de ML como endpoints REST de forma simple y eficiente.

• Su soporte de async/await es ideal para llamadas a APIs externas como OpenAI, Anthropic o Gemini.

• La documentación automática facilita la colaboración entre equipos de backend y frontend.

• Frameworks como LangChain y LlamaIndex se integran de forma nativa con FastAPI para construir APIs de chatbots o sistemas RAG (Retrieval-Augmented Generation).

Si tu interés está en cómo los equipos técnicos optimizan el ciclo de desarrollo con herramientas de IA, también puede interesarte leer sobre cómo hacer testing de software con IA, una práctica cada vez más común en equipos de LATAM.

Cursos de Coderhouse para profundizar

Si querés dominar el desarrollo de APIs con Python y posicionarte en el mercado tech:

• Carrera Desarrollo Backend: ideal si querés especializarte en el lado servidor, bases de datos y APIs REST desde cero.

• Carrera Desarrollo Full Stack: para quienes buscan dominar tanto el frontend como el backend, incluyendo tecnologías modernas para conectar APIs con interfaces de usuario.

• Curso AI Engineering: si ya tenés base en programación y querés especializarte en construir sistemas de IA sobre APIs como las que aprendiste a crear en esta guía.

Preguntas frecuentes

¿Necesito saber Python avanzado para aprender FastAPI?

No. Con conocimientos básicos de Python —funciones, tipos de datos, manejo de módulos— podés empezar a usar FastAPI. La curva de aprendizaje es gradual: empezás con endpoints simples y vas agregando validaciones, autenticación y conexiones a bases de datos a medida que avanzás.

¿FastAPI sirve para producción o solo para aprendizaje?

FastAPI está diseñado para producción. Empresas como Uber, Netflix y Microsoft lo usan en proyectos a gran escala. En LATAM, startups de fintech, healthtech y edtech lo adoptaron como estándar para sus backends con IA.

¿Cuál es la diferencia entre FastAPI y Django REST Framework?

Django REST Framework (DRF) está construido sobre Django y es ideal cuando necesitás un ORM completo, autenticación robusta y administración integrada. FastAPI es más liviano, más rápido y más simple para proyectos orientados a APIs puras, especialmente las que integran modelos de IA. Si tu proyecto es principalmente una API sin mucha lógica de admin, FastAPI suele ser la mejor opción.

¿FastAPI es compatible con GraphQL?

Sí. Podés integrar FastAPI con Strawberry o Ariadne para servir un esquema GraphQL junto con tus endpoints REST. Esto es útil cuando necesitás flexibilidad en las queries desde el cliente.

¿Cómo hago deploy de una API con FastAPI?

Las opciones más comunes son: Docker + servidor en Render, Railway o Fly.io (ideal para empezar), o directamente en AWS, GCP o Azure para proyectos empresariales. Uvicorn se puede ejecutar detrás de un proxy inverso como Nginx para mayor rendimiento en producción. La documentación oficial de FastAPI tiene guías de deploy para cada uno de estos entornos.