Fastrapi
⚡FastAPI alternative for Python, but actually (~6x) FASTER. Written in Rust.
Install / Use
/learn @ppmpreetham/FastrapiREADME
FastrAPI (Fast + Rust + API)
Key Features
- Lightning Speed: Powered by Rust and Axum, FastrAPI delivers up to 33x faster performance than FastAPI, making your APIs scream.
- Python-First: Write clean, familiar Python code, no Rust knowledge needed. FastrAPI handles the heavy lifting behind the scenes.
- Ironclad Type Safety: Inherits Rust's robust type system for rock-solid reliability, catching errors before they hit production.
- 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 FastAPI's beloved decorator syntax, so you can switch without rewriting your codebase.
Is it as fast as claimed?
Yes. Powered by Rust and Axum, FastrAPI outperforms FastAPI by up to 33x in real-world benchmarks, with no compromises on usability. Check it out here
Do I need to know Rust?
Nope. FastrAPI lets you write 100% Python code while leveraging Rust's performance under the hood.
Can it handle complex APIs?
Absolutely. With full Pydantic integration and async support, FastrAPI scales effortlessly for small projects and enterprise-grade APIs alike.
Will it keep up with FastAPI updates?
Yes. FastrAPI mirrors FastAPI's decorator-based syntax, ensuring compatibility and instant access to familiar workflows.
Installation
uv
uv install fastrapi
pip
pip install fastrapi
Switch from FastAPI
- from fastapi import FastAPI
+ from fastrapi import FastrAPI
Get Started
from fastrapi import FastrAPI
app = FastrAPI()
@app.get("/hello")
def hello():
return {"Hello": "World"}
@app.post("/echo")
def echo(data):
return {"received": data}
if __name__ == "__main__":
app.serve("127.0.0.1", 8080)
Now, test it with:
curl http://127.0.0.1:8080/hello
For the POST endpoint:
curl --location 'http://127.0.0.1:8080/echo' \
--header 'Content-Type: application/json' \
--data '{"foo": 123, "bar": [1, 2, 3]}'
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", 8080)
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", 8080)
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
# WARNING: ALWAYS return JSONResponse if it's JSON, to ensure proper serialization
@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/
Performance
Benchmarks using k6 show it outperforms FastAPI + Guvicorn across multiple worker configurations.
🖥️ Test Environment
- 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
⚡ Benchmark Results
| 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 |
TLDR; FASTRAPI handles thousands of requests per second with ultra-low latency , making it ~33× faster than FastAPI + Guvicorn with 1 worker.
Comparison: FastAPI vs FastRAPI
| Area | FastAPI | FastRAPI | FastRAPI wins? |
|-----------------------------------|-------------------------------------------------------|-------------------------------------------------------------|----------------|
| Dependency resolution | Runtime inspect + reflection every request | One-time parsing at decorator → pre-built injection plan | ✅ |
| Fast-path for trivial endpoints | No special case: full kwargs/dependency work always | is_fast_path flag → skip deps, validation, kwargs | ✅ |
| Route lookup speed | Starlette regex router (slows with many routes) | papaya concurrent hashmap → O(1) lookup | ✅ |
| Middleware usability (Python) | @app.middleware often buggy / limited | Clean, working decorator + real execution | ✅ |
| Background tasks reliability | Fire-and-forget, errors usually swallowed | Proper JoinHandle + error logging | ✅ |
| WebSocket implementation | Starlette (solid but heavy) | Custom with bounded channels + clean async pump | ✅ |
| Startup-time error detection | Almost everything deferred to runtime | Full signature + dependency analysis at decorator time | ✅ |
| Concurrency & resource safety | asyncio + threadpool | Native Tokio + Rust memory & thread safety | ✅ |
| Deployment footprint | Heavy (uvicorn + many deps) | Tiny Rust binary + optional Python runtime | ✅ |
| Scaling to 10,000+ routes | Noticeable slowdown | Stays fast thanks to hashmap lookup | ✅ |
| JSON serialization flexibility | Hard to swap (monkey-patch needed) | Trivial to plug orjson / sonic-rs / simdjson | ✅ |
| response_model=None + raw Response return | Fully supported | serialization | ❌ (for now) |
| APIRouter + include_router() | Yes, mature ecosystem | Not yet implemented | ❌ (for now) |
| app.mount() / StaticFiles | Yes | Not yet implemented | ❌ (for now) |
Current Limitations
Some advanced features are still in development like:
- [ ] Logging/metrics
- [ ] A nice logging tool
- [ ] Async Middleware support
- [ ] Lifespan Events (@app.on_startup / @app.on_shutdown)
- [ ] Better error handling (currently shows Rust errors)
- [ ] Rate limiter (ev
