fastrapi 0.2.3

A high-performance Python API framework powered by Rust

FastrAPI (Fast + Rust + API)

FastrAPI is a high-performance web framework that supercharges your Python APIs with the power of Rust. Built on Axum and PyO3, it delivers unmatched speed, type safety, and developer-friendly Python syntax. Create robust, async-ready APIs with minimal overhead and maximum throughput. FastrAPI is your drop-in replacement for FastAPI, offering familiar syntax with up to 33x faster performance.

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

Quick Start

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]}'

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", 8080)

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", 8080)

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
# 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.

Current Limitations

Some advanced features are still in development like:

• Logging/metrics
• A nice logging tool
• Better error handling (currently shows Rust errors)
• Rate limiter (even FastAPI doesn't have it)
• Websockets
• Dependency injection
• Static file serving
• Background tasks
• Testing support
• GraphQL support

Contributing

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.

License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgments

Inspired by FastAPI Built with PyO3 and Axum

Star History