FastAPI¶

Framework FastAPI, alto rendimiento, fácil de aprender, rápido de programar, listo para producción

Documentation: https://fastapi.tiangolo.com

Source Code: https://github.com/fastapi/fastapi

FastAPI es un framework web moderno, rápido (de alto rendimiento), para construir APIs con Python basado en los type hints estándar de Python.

Las características principales son:

• Rápido: Rendimiento muy alto, a la par con NodeJS y Go (gracias a Starlette y Pydantic). Uno de los frameworks de Python más rápidos disponibles.
• Rápido de programar: Incrementa la velocidad para desarrollar funcionalidades entre un 200% y un 300%. *
• Menos bugs: Reduce aproximadamente un 40% de los errores humanos (del desarrollador). *
• Intuitivo: Excelente soporte del editor. Autocompletado en todas partes. Menos tiempo haciendo debugging.
• Fácil: Diseñado para ser fácil de usar y aprender. Menos tiempo leyendo docs.
• Conciso: Minimiza la duplicación de código. Múltiples funcionalidades de cada declaración de parámetro. Menos bugs.
• Robusto: Obtén código listo para producción. Con documentación interactiva automática.
• Basado en estándares: Basado en (y totalmente compatible con) los estándares abiertos para APIs: OpenAPI (anteriormente conocido como Swagger) y JSON Schema.

* estimación basada en pruebas realizadas por un equipo de desarrollo interno, construyendo aplicaciones de producción.

Patrocinadores¶

Patrocinador Keystone¶

Patrocinadores Gold¶

Patrocinadores Silver¶

Otros patrocinadores

Opiniones¶

"Estoy usando FastAPI muchísimo estos días. De hecho, planeo usarlo para todos los servicios de ML de mi equipo en Microsoft. Algunos se están integrando en el producto central de Windows y en algunos productos de Office."

— Kabir Khan, Microsoft (ref)

FastAPI Conf¶

FastAPI Conf '26 se realizará el 28 de octubre de 2026 en Ámsterdam, NL. Todo sobre FastAPI, directamente de la fuente. 🎤

Mini documental de FastAPI¶

Hay un mini documental de FastAPI lanzado a finales de 2025, puedes verlo online:

Typer, el FastAPI de los CLIs¶

Si estás construyendo una app de CLI para usar en la terminal en lugar de una API web, échale un vistazo a Typer.

Typer es el hermanito de FastAPI. Y está pensado para ser el FastAPI de los CLIs. ⌨️ 🚀

Requisitos¶

FastAPI se apoya en hombros de gigantes:

• Starlette para las partes web.
• Pydantic para las partes de datos.

Instalación¶

Crea y activa un entorno virtual y luego instala FastAPI:

pip install "fastapi[standard]"
fast →pip install "fastapi[standard]"

restart ↻

Nota: Asegúrate de poner "fastapi[standard]" entre comillas para asegurar que funcione en todas las terminales.

Ejemplo¶

Créalo¶

Crea un archivo main.py con:

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():
    return {"Hello": "World"}


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

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def read_root():
    return {"Hello": "World"}


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

Ejecútalo¶

Ejecuta el servidor con:

fastapi dev
fast →fastapi dev
 ╭────────── FastAPI CLI - Development mode ───────────╮
 │                                                     │
 │  Serving at: http://127.0.0.1:8000                  │
 │                                                     │
 │  API docs: http://127.0.0.1:8000/docs               │
 │                                                     │
 │  Running in development mode, for production use:   │
 │                                                     │
 │  fastapi run                                        │
 │                                                     │
 ╰─────────────────────────────────────────────────────╯

INFO:     Will watch for changes in these directories: ['/home/user/code/awesomeapp']
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [2248755] using WatchFiles
INFO:     Started server process [2248757]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

restart ↻

Revísalo¶

Abre tu navegador en http://127.0.0.1:8000/items/5?q=somequery.

Verás la respuesta JSON como:

{"item_id": 5, "q": "somequery"}

Ya creaste una API que:

• Recibe peticiones HTTP en los paths / y /items/{item_id}.
• Ambos paths tienen operaciones GET (también conocidas como métodos HTTP).
• El path /items/{item_id} tiene un parámetro de path item_id que debería ser un int.
• El path /items/{item_id} tiene un parámetro de query q opcional de tipo str.

Documentación interactiva de la API¶

Ahora ve a http://127.0.0.1:8000/docs.

Verás la documentación interactiva automática de la API (proporcionada por Swagger UI):

Documentación alternativa de la API¶

Y ahora, ve a http://127.0.0.1:8000/redoc.

Verás la documentación alternativa automática (proporcionada por ReDoc):

Ejemplo mejorado¶

Ahora modifica el archivo main.py para recibir un body de una petición PUT.

Declara el body usando tipos estándar de Python, gracias a Pydantic.

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    price: float
    is_offer: bool | None = None


@app.get("/")
def read_root():
    return {"Hello": "World"}


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


@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    return {"item_name": item.name, "item_id": item_id}

El servidor de fastapi dev debería recargarse automáticamente.

Documentación interactiva de la API mejorada¶

Ahora ve a http://127.0.0.1:8000/docs.

• La documentación interactiva de la API se actualizará automáticamente, incluyendo el nuevo body:

• Haz clic en el botón "Try it out", te permite completar los parámetros e interactuar directamente con la API:

• Luego haz clic en el botón "Execute", la interfaz de usuario se comunicará con tu API, enviará los parámetros, obtendrá los resultados y los mostrará en pantalla:

Documentación alternativa de la API mejorada¶

Y ahora, ve a http://127.0.0.1:8000/redoc.

• La documentación alternativa también reflejará el nuevo parámetro de query y el body:

Resumen¶

En resumen, declaras una vez los tipos de los parámetros, body, etc. como parámetros de función.

Haces eso con tipos modernos estándar de Python.

No tienes que aprender una nueva sintaxis, los métodos o clases de una librería específica, etc.

Solo Python estándar.

Por ejemplo, para un int:

item_id: int

o para un modelo Item más complejo:

item: Item

...y con esa única declaración obtienes:

• Editor support, including:
  • Autocompletado.
  • Verificación de tipos.
• Validation of data:
  • Errores automáticos y claros cuando los datos son inválidos.
  • Validación incluso para objetos JSON profundamente anidados.
• Conversion of input data: coming from the network to Python data and types. Reading from:
  • JSON.
  • Parámetros de path.
  • Parámetros de query.
  • Cookies.
  • Headers.
  • Formularios.
  • Archivos.
• Conversion of output data: converting from Python data and types to network data (as JSON):
  • Convertir tipos de Python (str, int, float, bool, list, etc).
  • Objetos datetime.
  • Objetos UUID.
  • Modelos de base de datos.
  • ...y muchas más.
• Automatic interactive API documentation, including 2 alternative user interfaces:
  • Swagger UI.
  • ReDoc.

Volviendo al ejemplo de código anterior, FastAPI:

• Validará que haya un item_id en el path para las peticiones GET y PUT.
• Validate that the item_id is of type int for GET and PUT requests.
  • Si no lo es, el cliente verá un error útil y claro.
• Check if there is an optional query parameter named q (as in http://127.0.0.1:8000/items/foo?q=somequery) for GET requests.
  • Como el parámetro q está declarado con = None, es opcional.
  • Sin el None sería obligatorio (como lo es el body en el caso de PUT).
• For PUT requests to /items/{item_id}, read the body as JSON:
  • Verificará que tenga un atributo obligatorio name que debería ser un str.
  • Verificará que tenga un atributo obligatorio price que tiene que ser un float.
  • Verificará que tenga un atributo opcional is_offer, que debería ser un bool, si está presente.
  • Todo esto también funcionaría para objetos JSON profundamente anidados.
• Conversión desde y hacia JSON automáticamente.
• Document everything with OpenAPI, that can be used by:
  • Sistemas de documentación interactiva.
  • Sistemas de generación automática de código cliente, para múltiples lenguajes.
• Proporciona 2 interfaces web de documentación interactiva directamente.

Apenas rasguñamos la superficie, pero ya tienes una idea de cómo funciona todo.

Prueba cambiando la línea con:

    return {"item_name": item.name, "item_id": item_id}

...de:

        ... "item_name": item.name ...

...a:

        ... "item_price": item.price ...

...y mira cómo tu editor autocompletará los atributos y conocerá sus tipos:

Para un ejemplo más completo que incluya más funcionalidades, consulta el Tutorial - Guía de Usuario.

Alerta de spoiler: el tutorial - guía de usuario incluye:

• Declaración de parámetros desde otros lugares diferentes como: headers, cookies, campos de formulario y archivos.
• Cómo establecer restricciones de validación como maximum_length o regex.
• Un sistema de Dependency Injection muy potente y fácil de usar.
• Seguridad y autenticación, incluyendo soporte para OAuth2 con tokens JWT y auth HTTP Basic.
• Técnicas más avanzadas (pero igual de fáciles) para declarar modelos JSON profundamente anidados (gracias a Pydantic).
• Integración de GraphQL con Strawberry y otras librerías.
• Many extra features (thanks to Starlette) such as:
  • WebSockets
  • tests extremadamente fáciles basados en HTTPX y pytest
  • CORS
  • Cookie Sessions
  • ...y más.

Despliega tu app (opcional)¶

Opcionalmente puedes desplegar tu app FastAPI a FastAPI Cloud con un solo comando. 🚀

fastapi deploy
fast →fastapi deploy
Deploying to FastAPI Cloud...

✅ Deployment successful!

🐔 Ready the chicken! Your app is ready at https://myapp.fastapicloud.dev

restart ↻

El CLI detectará automáticamente tu aplicación FastAPI y la desplegará en la nube. Si no has iniciado sesión, tu navegador se abrirá para completar el proceso de autenticación.

¡Eso es todo! Ahora puedes acceder a tu app en esa URL. ✨

Acerca de FastAPI Cloud¶

FastAPI Cloud es construido por el mismo autor y equipo detrás de FastAPI.

Simplifica el proceso de construir, desplegar y acceder a una API con mínimo esfuerzo.

Trae la misma experiencia de desarrollador de construir apps con FastAPI a desplegarlas en la nube. 🎉

FastAPI Cloud es el principal patrocinador y proveedor de financiación para los proyectos open source de FastAPI and friends. ✨

Desplegar en otros proveedores de nube¶

FastAPI es de código abierto y está basado en estándares. Puedes desplegar aplicaciones FastAPI en cualquier proveedor de nube que elijas.

Sigue las guías de tu proveedor de nube para desplegar aplicaciones FastAPI con ellos. 🤓

Rendimiento¶

Los benchmarks independientes de TechEmpower muestran que las aplicaciones FastAPI ejecutándose bajo Uvicorn son uno de los frameworks de Python más rápidos disponibles, solo por debajo de Starlette y Uvicorn mismos (usados internamente por FastAPI). (*)

Para entender más sobre esto, consulta la sección Benchmarks.

Dependencias¶

FastAPI depende de Pydantic y Starlette.

Dependencias standard¶

Cuando instalas FastAPI con pip install "fastapi[standard]" viene con el grupo de dependencias opcionales standard:

Usado por Pydantic:

• email-validator - para validación de email.

Usado por Starlette:

• httpx - Necesario si quieres usar el TestClient.
• jinja2 - Necesario si quieres usar la configuración de template por defecto.
• python-multipart - Necesario si quieres soportar el "parsing" de formularios, con request.form().

Usado por FastAPI:

• uvicorn - para el servidor que carga y sirve tu aplicación. Esto incluye uvicorn[standard], que incluye algunas dependencias (e.g. uvloop) necesarias para servir con alto rendimiento.
• fastapi-cli[standard] - to provide the fastapi command.
  • Esto incluye fastapi-cloud-cli, que te permite desplegar tu aplicación FastAPI a FastAPI Cloud.

Sin Dependencias standard¶

Si no quieres incluir las dependencias opcionales standard, puedes instalar con pip install fastapi en lugar de pip install "fastapi[standard]".

Sin fastapi-cloud-cli¶

Si quieres instalar FastAPI con las dependencias standard pero sin el fastapi-cloud-cli, puedes instalar con pip install "fastapi[standard-no-fastapi-cloud-cli]".

Dependencias Opcionales Adicionales¶

Hay algunas dependencias adicionales que podrías querer instalar.

Dependencias opcionales adicionales de Pydantic:

• pydantic-settings - para gestión de settings.
• pydantic-extra-types - para tipos adicionales que usar con Pydantic.

Dependencias opcionales adicionales de FastAPI:

• orjson - Necesario si quieres usar ORJSONResponse.
• ujson - Necesario si quieres usar UJSONResponse.

Licencia¶

Este proyecto está licenciado bajo los términos de la licencia MIT.