FastAPI¶

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

Documentación:https://fastapi.tiangolo.com

Código Fuente:https://github.com/fastapi/fastapi

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

Las funcionalidades clave son:

• Rápido: Muy alto rendimiento, a la par conNodeJS yGo (gracias a Starlette y Pydantic).Uno de los frameworks Python más rápidos disponibles.
• Rápido de programar: Aumenta la velocidad para desarrollar funcionalidades en aproximadamente un 200% a 300%. *
• Menos bugs: Reduce en aproximadamente un 40% los errores inducidos por humanos (desarrolladores). *
• Intuitivo: Gran soporte para editores.Autocompletado en todas partes. Menos tiempo depurando.
• Fácil: Diseñado para ser fácil de usar y aprender. Menos tiempo leyendo documentación.
• Corto: Minimiza la duplicación de código. Múltiples funcionalidades desde 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 (y completamente compatible) con los estándares abiertos para APIs:OpenAPI (anteriormente conocido como Swagger) yJSON Schema.

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

Sponsors¶

Sponsor Keystone¶

Sponsors Oro y Plata¶

Otros sponsors

Opiniones¶

"[...] Estoy usandoFastAPI un montón estos días. [...] De hecho, estoy planeando usarlo para todos los servicios deML de mi equipo en Microsoft. Algunos de ellos se están integrando en el núcleo del productoWindows y algunos productos deOffice."

"Adoptamos el paqueteFastAPI para crear un servidorREST que pueda ser consultado para obtenerpredicciones. [para Ludwig]"

"Netflix se complace en anunciar el lanzamiento de código abierto de nuestro framework de orquestación degestión de crisis:Dispatch! [construido conFastAPI]"

"Estoy súper emocionado conFastAPI. ¡Es tan divertido!"

"Honestamente, lo que has construido parece súper sólido y pulido. En muchos aspectos, es lo que quería queHug fuera; es realmente inspirador ver a alguien construir eso."

"Si estás buscando aprender unframework moderno para construir APIs REST, échale un vistazo aFastAPI [...] Es rápido, fácil de usar y fácil de aprender [...]"

"Nos hemos cambiado aFastAPI para nuestrasAPIs [...] Creo que te gustará [...]"

"Si alguien está buscando construir una API de Python para producción, altamente recomendaríaFastAPI. Estáhermosamente diseñado, essimple de usar yaltamente escalable, se ha convertido en uncomponente clave en nuestra estrategia de desarrollo API primero y está impulsando muchas automatizaciones y servicios como nuestro Ingeniero Virtual TAC."

Mini documental de FastAPI¶

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

Typer, el FastAPI de las CLIs¶

Si estás construyendo una aplicación deCLI para ser usada en la terminal en lugar de una API web, revisaTyper.

Typer es el hermano pequeño de FastAPI. Y está destinado a ser elFastAPI de las 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 unentorno virtual y luego instala FastAPI:

$pipinstall"fastapi[standard]"---> 100%

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

Ejemplo¶

Créalo¶

Crea un archivomain.py con:

fromfastapiimportFastAPIapp=FastAPI()@app.get("/")defread_root():return{"Hello":"World"}@app.get("/items/{item_id}")defread_item(item_id:int,q:str|None=None):return{"item_id":item_id,"q":q}

fromfastapiimportFastAPIapp=FastAPI()@app.get("/")asyncdefread_root():return{"Hello":"World"}@app.get("/items/{item_id}")asyncdefread_item(item_id:int,q:str|None=None):return{"item_id":item_id,"q":q}

Córrelo¶

Corre el servidor con:

$fastapidevmain.py ╭────────── 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 WatchFilesINFO:     Started server process [2248757]INFO:     Waiting for application startup.INFO:     Application startup complete.

Revísalo¶

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

Verás el response JSON como:

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

Ya creaste una API que:

• Recibe requests HTTP en lospaths/ y/items/{item_id}.
• Ambospaths tomanoperacionesGET (también conocidas como métodos HTTP).
• Elpath/items/{item_id} tiene unparámetro de pathitem_id que debe ser unint.
• Elpath/items/{item_id} tiene unparámetro de queryq opcional que es unstr.

Documentación interactiva de la API¶

Ahora ve ahttp://127.0.0.1:8000/docs.

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

Documentación alternativa de la API¶

Y ahora, ve ahttp://127.0.0.1:8000/redoc.

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

Actualización del ejemplo¶

Ahora modifica el archivomain.py para recibir un body desde un requestPUT.

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

fromfastapiimportFastAPIfrompydanticimportBaseModelapp=FastAPI()classItem(BaseModel):name:strprice:floatis_offer:bool|None=None@app.get("/")defread_root():return{"Hello":"World"}@app.get("/items/{item_id}")defread_item(item_id:int,q:str|None=None):return{"item_id":item_id,"q":q}@app.put("/items/{item_id}")defupdate_item(item_id:int,item:Item):return{"item_name":item.name,"item_id":item_id}

El servidorfastapi dev debería recargarse automáticamente.

Actualización de la documentación interactiva de la API¶

Ahora ve ahttp://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 llenar 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 la pantalla:

Actualización de la documentación alternativa de la API¶

Y ahora, ve ahttp://127.0.0.1:8000/redoc.

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

Resumen¶

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

Lo haces con tipos estándar modernos de Python.

No tienes que aprender una nueva sintaxis, los métodos o clases de un paquete específico, etc.

SoloPython estándar.

Por ejemplo, para unint:

item_id:int

o para un modeloItem más complejo:

item:Item

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

• Soporte para editores, incluyendo:
  • Autocompletado.
  • Chequeo de tipos.
• Validación de datos:
  • Errores automáticos y claros cuando los datos son inválidos.
  • Validación incluso para objetos JSON profundamente anidados.
• Conversión de datos de entrada: de la red a los datos y tipos de Python. Leyendo desde:
  • JSON.
  • Parámetros de path.
  • Parámetros de query.
  • Cookies.
  • Headers.
  • Forms.
  • Archivos.
• Conversión de datos de salida: convirtiendo de datos y tipos de Python a datos de red (como JSON):
  • Convertir tipos de Python (str,int,float,bool,list, etc).
  • Objetosdatetime.
  • ObjetosUUID.
  • Modelos de base de datos.
  • ...y muchos más.
• Documentación interactiva automática de la API, incluyendo 2 interfaces de usuario alternativas:
  • Swagger UI.
  • ReDoc.

Volviendo al ejemplo de código anterior,FastAPI:

• Validará que haya unitem_id en el path para requestsGET yPUT.
• Validará que elitem_id sea del tipoint para requestsGET yPUT.
  • Si no lo es, el cliente verá un error útil y claro.
• Revisa si hay un parámetro de query opcional llamadoq (como enhttp://127.0.0.1:8000/items/foo?q=somequery) para requestsGET.
  • Como el parámetroq está declarado con= None, es opcional.
  • Sin elNone sería requerido (como lo es el body en el caso conPUT).
• Para requestsPUT a/items/{item_id}, leerá el body como JSON:
  • Revisa que tiene un atributo requeridoname que debe ser unstr.
  • Revisa que tiene un atributo requeridoprice que debe ser unfloat.
  • Revisa que tiene un atributo opcionalis_offer, que debe ser unbool, si está presente.
  • Todo esto también funcionaría para objetos JSON profundamente anidados.
• Convertirá de y a JSON automáticamente.
• Documentará todo con OpenAPI, que puede ser usado por:
  • Sistemas de documentación interactiva.
  • Sistemas de generación automática de código cliente, para muchos lenguajes.
• Proporcionará 2 interfaces web de documentación interactiva directamente.

Solo tocamos los conceptos básicos, pero ya te haces una idea de cómo funciona todo.

Intenta cambiar la línea con:

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

...desde:

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

...a:

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

...y observa cómo tu editor autocompleta los atributos y conoce sus tipos:

Para un ejemplo más completo incluyendo más funcionalidades, ve alTutorial - Guía del Usuario.

Alerta de spoilers: el tutorial - guía del usuario incluye:

• Declaración deparámetros desde otros lugares diferentes como:headers,cookies,campos de formulario yarchivos.
• Cómo establecerrestricciones de validación comomaximum_length oregex.
• Un sistema deInyección de Dependencias muy poderoso y fácil de usar.
• Seguridad y autenticación, incluyendo soporte paraOAuth2 contokens JWT y autenticaciónHTTP Basic.
• Técnicas más avanzadas (pero igualmente fáciles) para declararmodelos JSON profundamente anidados (gracias a Pydantic).
• Integración conGraphQL usandoStrawberry y otros paquetes.
• Muchas funcionalidades extra (gracias a Starlette) como:
  • WebSockets
  • pruebas extremadamente fáciles basadas en HTTPX ypytest
  • CORS
  • Sesiones de Cookies
  • ...y más.

Despliega tu app (opcional)¶

Opcionalmente puedes desplegar tu app de FastAPI enFastAPI Cloud, ve y únete a la lista de espera si no lo has hecho. 🚀

Si ya tienes una cuenta deFastAPI Cloud (te invitamos desde la lista de espera 😉), puedes desplegar tu aplicación con un solo comando.

Antes de desplegar, asegúrate de haber iniciado sesión:

$fastapiloginYou are logged in to FastAPI Cloud 🚀

Luego despliega tu app:

$fastapideployDeploying to FastAPI Cloud...✅ Deployment successful!🐔 Ready the chicken! Your app is ready at https://myapp.fastapicloud.dev

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

Acerca de FastAPI Cloud¶

FastAPI Cloud está construido por el mismo autor y equipo detrás deFastAPI.

Optimiza el proceso deconstruir,desplegar yacceder a una API con un esfuerzo mínimo.

Trae la mismaexperiencia de desarrollador de construir apps con FastAPI adesplegarlas en la nube. 🎉

FastAPI Cloud es el sponsor principal y proveedor de financiamiento para los proyectos open sourceFastAPI and friends. ✨

Despliega en otros proveedores de cloud¶

FastAPI es open source y está basado en estándares. Puedes desplegar apps de FastAPI en cualquier proveedor de cloud que elijas.

Sigue las guías de tu proveedor de cloud para desplegar apps de FastAPI con ellos. 🤓

Rendimiento¶

Benchmarks independientes de TechEmpower muestran aplicacionesFastAPI ejecutándose bajo Uvicorn comouno de los frameworks Python más rápidos disponibles, solo por debajo de Starlette y Uvicorn (usados internamente por FastAPI). (*)

Para entender más sobre esto, ve la secciónBenchmarks.

Dependencias¶

FastAPI depende de Pydantic y Starlette.

Dependenciasstandard¶

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

Usadas por Pydantic:

• email-validator - para validación de correos electrónicos.

Usadas por Starlette:

• httpx - Requerido si deseas usar elTestClient.
• jinja2 - Requerido si deseas usar la configuración de plantilla por defecto.
• python-multipart - Requerido si deseas soportar form"parsing", conrequest.form().

Usadas por FastAPI:

• uvicorn - para el servidor que carga y sirve tu aplicación. Esto incluyeuvicorn[standard], que incluye algunas dependencias (por ejemplo,uvloop) necesarias para servir con alto rendimiento.
• fastapi-cli[standard] - para proporcionar el comandofastapi.
  • Esto incluyefastapi-cloud-cli, que te permite desplegar tu aplicación de FastAPI enFastAPI Cloud.

Sin Dependenciasstandard¶

Si no deseas incluir las dependencias opcionalesstandard, puedes instalar conpip install fastapi en lugar depip install "fastapi[standard]".

Sinfastapi-cloud-cli¶

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

Dependencias Opcionales Adicionales¶

Existen algunas dependencias adicionales que podrías querer instalar.

Dependencias opcionales adicionales de Pydantic:

• pydantic-settings - para la gestión de configuraciones.
• pydantic-extra-types - para tipos extra para ser usados con Pydantic.

Dependencias opcionales adicionales de FastAPI:

• orjson - Requerido si deseas usarORJSONResponse.
• ujson - Requerido si deseas usarUJSONResponse.

Licencia¶

Este proyecto tiene licencia bajo los términos de la licencia MIT.