Note
Not all features are supported yet. Check the Limitations for more info.
FastAPI is a Python web framework which is also a drop in replacement for FastAPI.
You change your code by directly replacing one character (fastapi -> fasterapi) and enjoy the performance benefits.
- High Speed: Powered by Rust and Axum, FastrAPI delivers up to 6x faster performance than FastAPI, making your APIs scream.
- Python First: Write same Python code, 0 Rust knowledge needed. FastrAPI handles the heavy lifting behind the scenes.
- Pydantic Powered: Seamless integration with Pydantic for effortless request and response validation, keeping your data in check.
- Async Native: Built on Tokio's async runtime, FastrAPI maximizes concurrency for handling thousands of requests with ease.
- Ultra Lightweight: Minimal runtime overhead with maximum throughput.
- Drop in Replacement: Drop in compatibility with the same FastAPI's beloved decorator syntax, so you can switch without rewriting your codebase.
- Middleware Support:
tower-httpsupport for CORS, GZip, Session, and TrustedHost middleware, plus sync/async Python middlewares and Starlette-stylecall_nextclasses viaapp.add_middleware(Cls).
Yes. Powered by Rust and Axum, FastrAPI outperforms FastAPI by up to 6x in real-world benchmarks, with no compromises on usability. Check it out here
Nope. FastrAPI lets you write 100% Python code while still leveraging Rust's performance under the hood.
Absolutely, FastrAPI scales effortlessly for small projects and massive enterprise grade APIs alike.
Yes. FastrAPI mirrors FastAPI's syntax, ensuring compatibility and instant access to workflows.
uv install fastrapipip install fastrapimaturin build --release --generate-stubs- from fastapi import FastAPI
+ from fastrapi import FastrAPIfrom fastrapi import FastrAPI
app = FastrAPI()
@app.get("/hello")
def hello():
return {"Hello": "World"}
@app.get("/healthz", cache_resp=True)
def healthz():
return {"ok": True}
@app.post("/echo")
def echo(data):
return {"received": data}
if __name__ == "__main__":
app.serve("127.0.0.1", 8000)curl http://127.0.0.1:8000/helloFor the POST endpoint:
curl --location 'http://127.0.0.1:8000/echo' \
--header 'Content-Type: application/json' \
--data '{"foo": 123, "bar": [1, 2, 3]}'Show Pydantic example
from pydantic import BaseModel
from fastrapi import FastrAPI
api = FastrAPI()
class User(BaseModel):
name: str
age: int
@api.post("/create_user")
def create_user(data: User):
return {"msg": f"Hello {data.name}, age {data.age}"}
api.serve("127.0.0.1", 8000)Show ResponseTypes Example
from fastrapi import FastrAPI
from fastrapi.responses import HTMLResponse, JSONResponse
api = FastrAPI()
@api.get("/html")
def get_html() -> HTMLResponse:
return HTMLResponse("<h1>Hello</h1>")
api.serve("127.0.0.1", 8000)Show Middleware Example
from fastrapi import FastrAPI
from fastrapi.responses import JSONResponse
from fastrapi.middleware import (
CORSMiddleware,
TrustedHostMiddleware,
GZipMiddleware,
SessionMiddleware
)
app = FastrAPI()
# TrustedHost Middleware
app.add_middleware(
TrustedHostMiddleware,
allowed_hosts=["127.0.0.1", "localhost", "127.0.0.1:8000"],
www_redirect=True
)
# CORS Middleware
app.add_middleware(
CORSMiddleware,
allow_origins=["*"],
allow_methods=["GET", "POST"],
allow_headers=["*"],
allow_credentials=False
)
# 3. GZip Middleware
app.add_middleware(
GZipMiddleware,
minimum_size=500,
compresslevel=9
)
# 4. Session Middleware
app.add_middleware(
SessionMiddleware,
secret_key="super-duper-secret-key-change-this-in-prod-pwease-uwu-BUT-MAKE-IT-LONGER-NOW",
session_cookie="fastrapi_session",
max_age=3600,
https_only=False
)
# ROUTES
@app.get("/")
def index() -> JSONResponse:
return JSONResponse({"status": "running"})
@app.get("/heavy")
def heavy_data() -> JSONResponse:
# response large enough to trigger GZip compression
large_data = "x" * 1000
return JSONResponse({
"data": large_data,
"note": "Check content-encoding header!"
})
# Session Test: Increment a counter stored in the cookie
@app.get("/counter")
def session_counter(request) -> JSONResponse:
# For now, this verifies the Middleware sets the cookie correctly.
return JSONResponse({"message": "Session cookie should be set"})
if __name__ == "__main__":
app.serve("127.0.0.1", 8000)
# Test with:
# curl -v -H "Host: 127.0.0.1" http://127.0.0.1:8000/
# curl -v -H "Origin: http://example.com" http://127.0.0.1:8000/Show Lifespan Example
from contextlib import asynccontextmanager
from fastrapi import FastrAPI
shared = {}
@asynccontextmanager
async def lifespan(app: FastrAPI):
shared["ready"] = True
app.title = "FastrAPI && lifespan"
try:
yield
finally:
shared.clear()
app = FastrAPI(lifespan=lifespan)
@app.get("/health")
def health():
return {"ready": shared.get("ready", False), "title": app.title}
app.serve("127.0.0.1", 8080)If you provide lifespan=..., on_startup and on_shutdown handlers are not called.
Show Startup / Shutdown Example
from fastrapi import FastrAPI
events = []
def startup():
events.append("startup")
async def shutdown():
events.append("shutdown")
app = FastrAPI(
on_startup=[startup],
on_shutdown=[shutdown],
)
@app.get("/events")
def get_events():
return {"events": events}
app.serve("127.0.0.1", 8080)Use cache_resp=True only for immutable responses. FastrAPI calls the handler during startup, stores the rendered response bytes and headers, and serves that route through a no-Python Axum path.
@app.get("/", cache_resp=True)
def hello():
return {"Hello": "World"}Benchmarks using k6 show it outperforms FastAPI + Guvicorn across multiple worker configurations.
For real benchmark numbers, build the PyO3 extension in release mode first:
maturin develop --release
python benchmarks/run_benchmark.py --benchmark const --framework bothIf you benchmark a debug build, Rust-side overhead will be much higher and the numbers will be misleading.
- Kernel: 6.16.8-arch3-1
- CPU: AMD Ryzen 7 7735HS (16 cores, 4.83 GHz)
- Memory: 15 GB
- Load Test: 20 Virtual Users (VUs), 30s
| Framework | Avg Latency (ms) | Median Latency (ms) | Requests/sec | P95 Latency (ms) | P99 Latency (ms) |
|---|---|---|---|---|---|
| FASTRAPI | 0.59 | 0.00 | 31360 | 2.39 | 11.12 |
| FastAPI + Guvicorn (workers: 1) | 21.08 | 19.67 | 937 | 38.47 | 93.42 |
| FastAPI + Guvicorn (workers: 16) | 4.84 | 4.17 | 3882 | 10.22 | 81.20 |
These numbers are historical, machine-specific results, not a universal guarantee. Re-run the scenario benchmarks on the same hardware and build profile before making performance claims.
Contributions are welcome! Please feel free to submit a Pull Request.
- Fork the repository
- Create your feature branch (git checkout -b feature/amazing-feature)
- Commit your changes (git commit -m 'Add some amazing feature')
- Push to the branch (git push origin feature/amazing-feature)
- Open a Pull Request
Check out CONTRIBUTING.md for more details.
This project is licensed under the MIT License - see the LICENSE file for details.

