Python API Framework Benchmark: FastAPI vs Django vs Litestar on Real Database Workloads

Framework benchmarks usually measure one thing: how fast a framework can serialize JSON. That’s a fine number, but it’s not what most of us ship. Most real APIs spend their time talking to a database.

So I benchmarked the major Python frameworks with real PostgreSQL workloads — complex queries, nested relationships, and properly optimized eager loading for each framework (select_related/prefetch_related for Django, selectinload for SQLAlchemy). Every framework was tested with multiple production servers in isolated Docker containers with strict resource limits.

All queries follow each framework’s best practices. This is a comparison of properly written production code, not naive implementations.

TL;DR: Performance differences collapse from 20x (plain JSON) to 1.7x (paginated queries) to 1.3x (complex detail queries). Database I/O is the great equalizer — framework choice barely matters for database-heavy apps.

Full results, code, and a reproducible Docker setup: python-api-frameworks-benchmark

Table of contents

What was tested

Frameworks and servers:

• Django Bolt (runbolt server)
• FastAPI (uvicorn, granian)
• Litestar (uvicorn, granian)
• Django REST Framework (uvicorn, granian, gunicorn + gevent)
• Django Ninja (uvicorn, granian)

Setup:

• Hardware: MacBook M2 Pro, 32GB RAM
• Database: PostgreSQL with realistic data (500 articles, 2,000 comments, 100 tags, 50 authors)
• Isolation: each framework in its own Docker container — 500MB RAM limit, 1 CPU core, run sequentially so nothing competes for resources
• Load: 100 concurrent connections, 10s duration, best of 3 runs

Endpoints:

Results

1. Simple JSON (/json-1k)

A 20x difference between fastest and slowest — this is the number most benchmarks stop at.

2. Paginated articles (/articles?page=1&page_size=20)

Add a real database query with nested relations and the gap shrinks to 1.7x. Query optimization is now the bottleneck.

3. Article detail (/articles/1)

Single article with all nested data (author + tags + comments): the gap narrows to 1.3x. The frameworks are nearly indistinguishable.

Complete summary

Resource usage

Memory: most frameworks sat at 170–220MB. The outlier was DRF on Granian’s WSGI mode at 640–670MB — a difference in protocol handling (WSGI vs ASGI), not a performance problem.

CPU: most frameworks saturated the 1-core limit under load; the Granian variants consistently maxed out CPU across all frameworks.

Server notes

• Uvicorn surprisingly won for Litestar (31,745 RPS), beating Granian
• Granian delivered consistently high performance for FastAPI and others
• Gunicorn + gevent held up fine for DRF on simple queries but struggled once database workloads got heavier

Takeaways

1. The performance gap collapses: 20x on JSON serialization → 1.7x on paginated queries → 1.3x on complex queries.
2. Litestar dominates simple workloads, but FastAPI actually wins the complex detail query. At that point they’re all within noise of each other.
3. Database I/O is the equalizer. Once you hit the database, framework overhead becomes negligible. Query optimization matters infinitely more than framework choice.

Bottom line: if you’re building a database-heavy API — which most of us are — spend your time optimizing queries, not agonizing over frameworks. Properly optimized, they all perform nearly identically. (And if you want help finding those unoptimized queries in Django, that’s exactly what my nplus1 package is for.)

Everything is reproducible: github.com/huynguyengl99/python-api-frameworks-benchmark. Feedback and PRs welcome.