# FastAPI — High Performance Python Web Framework for APIs

> FastAPI is a modern, fast Python web framework for building APIs. Based on standard Python type hints, it provides automatic OpenAPI docs, data validation via Pydantic, async support, and performance comparable to Node.js and Go frameworks.

## Install

Save as a script file and run:

# FastAPI — High Performance Python Web Framework for APIs

## Quick Use
```bash
# Install FastAPI
pip install "fastapi[standard]"

# Create main.py
cat > main.py << 'PYEOF'
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):
    return {"item_id": item_id, "q": q}
PYEOF

# Run the server
fastapi dev main.py
# Docs available at http://127.0.0.1:8000/docs
```

## Introduction
FastAPI is a modern Python web framework designed specifically for building APIs. Created by Sebastian Ramirez, it leverages Python type hints to provide automatic request validation, serialization, and interactive API documentation — with performance that rivals Node.js and Go.

With over 97,000 GitHub stars, FastAPI has become the fastest-growing Python web framework and the preferred choice for building REST APIs, microservices, and ML model serving endpoints. Companies like Microsoft, Uber, Netflix, and Nvidia use it in production.

## What FastAPI Does
FastAPI combines the simplicity of Flask with the type safety of modern Python. You define your API endpoints using standard Python functions with type hints. FastAPI automatically generates OpenAPI documentation, validates request data, serializes responses, and handles async operations — all from your type annotations.

## Architecture Overview
```
[Client Request]
       |
  [Uvicorn / Hypercorn]
  ASGI server (async)
       |
  [FastAPI Application]
       |
  +----+----+----+
  |    |    |    |
[Path] [Query] [Body]
params params  Pydantic
typed  typed   models
  |    |    |    |
  +----+----+----+
       |
  [Route Handler]
  async/sync function
  with dependency injection
       |
  [Response Model]
  Auto-serialization
  with OpenAPI schema
       |
  [JSON Response]
  + Auto-generated docs
    at /docs (Swagger UI)
    at /redoc (ReDoc)
```

## Self-Hosting & Configuration
```python
# Full example with Pydantic models and async
from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel
from typing import Optional

app = FastAPI(title="My API", version="1.0.0")

class Item(BaseModel):
    name: str
    price: float
    description: Optional[str] = None

class ItemResponse(BaseModel):
    id: int
    name: str
    price: float

items_db: dict[int, Item] = {}

@app.post("/items/", response_model=ItemResponse)
async def create_item(item: Item):
    item_id = len(items_db) + 1
    items_db[item_id] = item
    return ItemResponse(id=item_id, **item.model_dump())

@app.get("/items/{item_id}", response_model=ItemResponse)
async def get_item(item_id: int):
    if item_id not in items_db:
        raise HTTPException(status_code=404, detail="Item not found")
    return ItemResponse(id=item_id, **items_db[item_id].model_dump())
```

```bash
# Production deployment
pip install uvicorn
uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4
```

## Key Features
- **Type-Driven** — Python type hints drive validation, serialization, and docs
- **Auto Documentation** — Swagger UI and ReDoc generated automatically
- **Pydantic Integration** — powerful data validation and settings management
- **Async Native** — full async/await support for high concurrency
- **Dependency Injection** — declarative dependency system for clean architecture
- **High Performance** — on par with Node.js and Go frameworks (via Starlette + Uvicorn)
- **Standards Based** — fully compatible with OpenAPI 3.1 and JSON Schema
- **WebSocket Support** — built-in WebSocket endpoints

## Comparison with Similar Tools
| Feature | FastAPI | Flask | Django REST | Express | Gin |
|---|---|---|---|---|---|
| Language | Python | Python | Python | JavaScript | Go |
| Performance | Very High | Moderate | Moderate | High | Very High |
| Type Safety | Built-in | Manual | Serializers | Manual | Struct tags |
| Auto Docs | Yes (OpenAPI) | Via extension | Yes | Via middleware | Via middleware |
| Async | Native | Limited | Limited | Native | Goroutines |
| Learning Curve | Low | Very Low | Moderate | Low | Low |
| Best For | APIs, ML serving | Simple apps | Full-stack | Full-stack | Microservices |

## FAQ
**Q: FastAPI vs Flask — which should I choose?**
A: FastAPI for APIs and microservices — you get automatic validation, documentation, and async support. Flask for simple web apps, server-rendered pages, or when you prefer maximum flexibility with minimal opinions.

**Q: Is FastAPI production-ready?**
A: Absolutely. FastAPI is used at Microsoft, Uber, Netflix, and many other companies in production. Deploy with Uvicorn behind Nginx or use Gunicorn with Uvicorn workers.

**Q: How does FastAPI compare to Django REST Framework?**
A: FastAPI is faster, more modern (async, type hints), and better for pure API projects. Django REST Framework is better when you need Django ORM, admin panel, and the full Django ecosystem.

**Q: Can I use FastAPI for serving ML models?**
A: Yes, FastAPI is the most popular choice for ML model serving. Its async support handles concurrent inference requests well, and Pydantic models define clean input/output schemas.

## Sources
- GitHub: https://github.com/fastapi/fastapi
- Documentation: https://fastapi.tiangolo.com
- Created by Sebastian Ramirez
- License: MIT

---
Source: https://tokrepo.com/en/workflows/0fc44c46-366d-11f1-9bc6-00163e2b0d79
Author: Script Depot