Best Framework to Build an API in Python

In the previous article we figured out what an API is and how it works - a set of rules and protocols that allows different software applications to communicate with each other. Now, let’s explore how to choose the best framework for building APIs in Python.

Each article covers a different topic. If you’re just starting to understand how to write your own API, it’s useful to read everything in order. If you already know it and are interested in a particular topic, go straight to it.

1. Simple Explanation of API
2. Best Framework for API (this article 👇)
3. Build API with FastAPI (soon)
4. Build API with Litestar (new!)
5. Top Tools to Test API (soon)
6. Make Money on API (soon)

Let’s dive in…

API Development

The Python ecosystem for API development has evolved significantly since this article was first published. Today’s applications demand high performance, asynchronous capabilities, automatic documentation, and type safety. Before examining specific frameworks, it’s important to understand key considerations for modern API development:

• Performance requirements: Modern APIs often need to handle thousands of concurrent requests, with FastAPI capable of processing over 10,000 requests per second with 50ms average response times.
• Type safety and validation: Strong typing helps catch errors early and enables automatic documentation generation, with frameworks like FastAPI using Pydantic to reduce runtime errors by 40% compared to manual validation.
• Documentation automation: OpenAPI/Swagger integration is now expected for professional APIs, saving developers 8-10 hours per project on documentation.
• Scalability needs: Your framework should support horizontal scaling and microservices architecture if needed.
• Developer experience: The framework’s learning curve, community support, and ecosystem maturity matter tremendously, with 92% of developers considering built-in testing interfaces essential.

ASGI vs WSGI

A key distinction in Python web frameworks is whether they use WSGI (Web Server Gateway Interface) or ASGI (Asynchronous Server Gateway Interface):

• WSGI Frameworks: Traditional synchronous frameworks like Flask and Django (without channels). They handle one request at a time, which can lead to blocking operations.
• ASGI Frameworks: Modern asynchronous frameworks like FastAPI, Litestar, and Starlette. They can handle multiple concurrent requests, making them significantly more performant for I/O-bound operations.

ASGI’s event loop model enables non-blocking I/O, which is critical for real-time APIs and high-concurrency workloads. Benchmarks show that ASGI reduces tail latency by 60% compared to WSGI under 10,000 concurrent users. For high-traffic APIs or applications with many concurrent users, ASGI frameworks generally provide better performance and resource utilization.

Now, let’s explore the best Python API frameworks, organized by type:

API frameworks

To pick a tool that will allow you to write APIs in Python quickly and efficiently, you need to consider the following things:

• Project size. If your API will be part of a full-fledged web application, it’s best to choose a framework that allows you to create both the web application itself and its API part. If all you need is the API, any of the micro frameworks will do.

• Workload. This is usually directly determined by the CPU and memory requirements of the server. The most obvious parameter is the number of client-server requests the server can handle.

• Time to assimilate. As a rule, the more powerful a framework is, the more time is required to learn it. If you already have a good command of a tool, of course, you can disregard this parameter.

A special case is a simple one, when all you need is a client to retrieve data from an existing API. To create it you can use embedded module or any of the popular libraries, like httplib2 or everyone’s favorite requests. Although it’s not directly related to the topic, we’ll take a look at them to complete the picture.

Let’s now look at the best REST API frameworks in Python that are actively supported and developed, as well as popular with developers and widely used nowadays. For your convenience, I’ve divided them into three conditional categories:

• Client libraries
• Micro frameworks (minimal set of features)
• Full-stack frameworks (comprehensive feature set)

Let’s start with client libraries, which are essential when you need to consume existing APIs.

Client Libraries

Requests

Site: https://github.com/psf/requests

Type: Client Library

Requests remains the gold standard for HTTP client libraries in Python. Its intuitive API, comprehensive feature set, and robust error handling make it the preferred choice for API consumption. The library supports all HTTP methods and advanced features such as authentication, session cookies, SSL, and more.

Working with Requests is straightforward:

>>> import requests
>>> URL = 'https://httpbin.org/basic-auth/user/pass'
>>> r = requests.get(URL, auth=('user', 'pass'))
>>> r.status_code
200
>>> r.headers['content-type']
'application/json; charset=utf8'
>>> r.encoding
'utf-8'
>>> r.text
'{"authenticated": true, ...'
>>> r.json()
{'authenticated': True, ...}

Requests is ideal for simple API client needs and is actively maintained with excellent documentation.

httpx

Site: https://www.python-httpx.org/

Type: Client Library

httpx is a modern alternative to Requests that offers both synchronous and asynchronous API client capabilities. It provides a familiar API similar to Requests but adds support for HTTP/2, async/await syntax, and other modern features.

Example of making asynchronous requests with httpx:

import asyncio
import httpx

async def fetch_data():
    async with httpx.AsyncClient() as client:
        response = await client.get('https://httpbin.org/get')
        return response.json()

asyncio.run(fetch_data())

The library is gaining popularity for modern applications that need both synchronous and asynchronous HTTP client capabilities.

urllib3

Site: https://urllib3.readthedocs.io/en/stable/

Type: Client Library

urllib3 is a powerful and thread-safe HTTP client for Python. It provides connection pooling, file uploads, form handling, and robust error management. Many Python packages, including Requests, use urllib3 under the hood.

>>> import urllib3
>>> http = urllib3.PoolManager(num_pools=2)
>>> resp = http.request('GET', 'http://httpbin.org/robots.txt')
>>> resp.status
200
>>> resp.data
b"User-agent: *\nDisallow: /deny\n"

urllib3 is particularly useful when you need fine-grained control over connection pooling and reuse.

Micro Frameworks

FastAPI

Site: https://fastapi.tiangolo.com/

Type: Micro framework

FastAPI has become one of the most popular API frameworks in the Python ecosystem since its introduction. Built on Starlette and Pydantic, it combines high performance with developer-friendly features.

Key strengths of FastAPI:

• Asynchronous performance: FastAPI is one of the fastest Python frameworks available, with performance comparable to Node.js and Go in some benchmarks.
• Type hinting integration: Leverages Python’s type hints for automatic request validation and documentation.
• OpenAPI documentation: Generates API documentation via Swagger UI and ReDoc.
• Data validation: Built-in validation via Pydantic models.
• Dependency injection: Powerful system for managing dependencies.

Source Code: https://github.com/fastapi/fastapi (over 84K stars as of 2025)

Creating a simple API with FastAPI:

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}

FastAPI remains an excellent choice for modern API development, especially for projects that need high performance and automatic documentation. My personal favorite 🤩.

Litestar

Site: https://litestar.dev/

Type: Micro framework

Litestar is a powerful ASGI framework that has gained significant traction in recent years. It focuses on building high-performance APIs with strong typing, dependency injection, and comprehensive validation features.

Key features of Litestar:

• High performance: Consistently performs well in benchmarks, matching or exceeding other ASGI frameworks.
• Type safety: Strict typing enforcement helps catch errors early and enables automatic documentation.
• Multiple data validation options: Supports dataclasses, TypedDict, msgspec, Pydantic (both v1 and v2), and attrs.
• First-class ORM integration: Excellent SQLAlchemy support reduces code duplication.
• Rich plugin ecosystem: Extensible architecture with numerous plugins.

Simple example of a Litestar application:

from litestar import Litestar, get

@get("/")
async def hello_world() -> dict[str, str]:
    """Keeping the tradition alive with hello world."""
    return {"hello": "world"}

app = Litestar(route_handlers=[hello_world])

Litestar also supports class-based controllers for more organized API development:

from typing import List
from litestar import Controller, get, post, put, patch, delete
from litestar.dto import DTOData
from pydantic import UUID4
from my_app.models import User, PartialUserDTO

class UserController(Controller):
    path = "/users"
    
    @post()
    async def create_user(self, data: User) -> User:
        # Implementation
        pass
    
    @get()
    async def list_users(self) -> List[User]:
        # Implementation
        pass
        
    @get(path="/{user_id:uuid}")
    async def get_user(self, user_id: UUID4) -> User:
        # Implementation
        pass

Litestar is an excellent choice for developers who appreciate class-based organization and need high performance with modern features.

Flask

Site: https://flask.palletsprojects.com/en/stable/

Type: Micro framework

Flask continues to be one of the most widely used Python frameworks for web application development, including APIs. Its simplicity, flexibility, and extensive ecosystem make it a popular choice, especially for smaller projects or developers who value simplicity.

For API development, Flask can be enhanced with extensions:

• Flask-RESTful: Simplifies building REST APIs
• Flask-RESTX: Adds Swagger documentation
• Flask-APISpec: Adds OpenAPI specification support

A simple Flask API example:

from flask import Flask, jsonify, request

app = Flask(__name__)

@app.route('/api/items', methods=['GET'])
def get_items():
    return jsonify({'items': ['item1', 'item2']})

@app.route('/api/items/<int:item_id>', methods=['GET'])
def get_item(item_id):
    return jsonify({'item_id': item_id, 'name': f'Item {item_id}'})

if __name__ == '__main__':
    app.run(debug=True)

While Flask lacks the built-in asynchronous capabilities and automatic documentation of newer frameworks, it remains an excellent choice for simpler APIs or when working with existing Flask applications.

Starlette

Site: https://www.starlette.io/

Type: Micro framework

Starlette is a lightweight ASGI framework that provides the foundation for many other frameworks, including FastAPI and Litestar. It offers excellent performance and the core components needed for building async web applications.

Key features:

• High performance: Designed for speed and efficiency
• Asynchronous: Fully supports async/await
• WebSocket support: Built-in support for WebSockets
• Minimal design: Focuses on core functionality

Example of a simple Starlette API:

from starlette.applications import Starlette
from starlette.responses import JSONResponse
import uvicorn

app = Starlette(debug=True)

@app.route('/')
async def homepage(request):
    return JSONResponse({'hello': 'world'})

if __name__ == '__main__':
    uvicorn.run(app, host='0.0.0.0', port=8000)

Starlette is ideal for developers who want a minimalist framework with high performance and asynchronous capabilities, without the additional abstractions of higher-level frameworks.

BlackSheep

Site: https://github.com/Neoteroi/BlackSheep

Type: Micro framework

BlackSheep is an emerging ASGI framework inspired by both Flask and ASP.NET Core. It offers high-performance routing and handling with modern asynchronous capabilities.

Key features:

• High-performance: Designed for modern asynchronous Python
• Built-in dependency injection: Simplifies component management
• Automatic OpenAPI documentation: Generates API documentation
• Type annotations: Used for route parameters binding

Simple example:

from datetime import datetime
from blacksheep.server import Application
from blacksheep.server.responses import text

app = Application()

@app.route('/')
async def home(request):
    return text(f'Hello, World! {datetime.utcnow().isoformat()}')

BlackSheep is worth considering for developers coming from an ASP.NET background or those seeking a modern ASGI framework with built-in dependency injection.

Quart

Site: https://palletsprojects.com/projects/quart

Type: Micro framework

Quart is an ASGI framework that aims to be a drop-in replacement for Flask while adding support for asynchronous request handling. It maintains Flask’s intuitive API but enables async/await syntax.

Key features:

• Flask compatibility: Can use many Flask extensions directly
• Asynchronous: Full support for async/await
• WebSockets: Native WebSocket support
• HTTP/2: Support for HTTP/2 server push

Example:

from quart import Quart, websocket

app = Quart(__name__)

@app.route('/')
async def hello():
    return 'Hello, World!'

@app.websocket('/ws')
async def ws():
    while True:
        await websocket.send('Hello, WebSocket!')

if __name__ == '__main__':
    app.run()

Quart is an excellent choice for Flask developers who need asynchronous capabilities without rewriting their applications.

Falcon

Site: https://falconframework.org/

Type: Micro framework

Falcon remains a high-performance framework focused on building RESTful APIs. Its minimal design and speed make it suitable for microservices and API backends.

Key features:

• Performance: Designed for speed and efficiency
• Minimalist design: Focuses on the essentials
• WSGI compatibility: Works with standard WSGI servers
• Request/response oriented: Clear separation of concerns

Example:

import falcon

class QuoteResource:
    def on_get(self, req, resp):
        """Handles GET requests"""
        quote = {
            'quote': "I've always been more interested in the future than in the past.",
            'author': 'Grace Hopper'
        }
        resp.media = quote

api = falcon.App()
api.add_route('/quote', QuoteResource())

Falcon is ideal for developers who prioritize performance and prefer a more explicit, class-based approach to API design.

Robyn

Site: https://github.com/sparckles/Robyn

Type: Micro framework

Robyn is an emerging Python web framework built on top of Rust, designed for exceptional performance. It’s gaining attention for applications where every millisecond matters.

Key features:

• Rust-based performance: Outperforms pure Python frameworks by 15-20% by offloading routing logic to Rust
• Hot reloading: Reduces iteration cycles by applying code changes without server restarts
• Python simplicity: Maintains a simple Python API while leveraging Rust’s speed
• Lightweight: Minimal overhead for high-performance applications

Example:

from robyn import Robyn

app = Robyn(__file__)

@app.get("/")
async def hello_world():
    return "Hello, World!"

if __name__ == "__main__":
    app.start(port=8000)

Robyn is worth considering for performance-critical applications or when you need to optimize for p99 latency under 50ms.

Full-stack Frameworks

Django REST

Site: https://www.django-rest-framework.org/

Type: Extension for a Full-stack framework

Django REST Framework (DRF) continues to be the go-to solution for building APIs on top of Django. It provides a comprehensive set of tools for serialization, authentication, permissions, viewsets, and more.

Key strengths:

• Rich ecosystem: Benefits from Django’s mature ecosystem
• Comprehensive authentication: Built-in support for multiple auth methods
• Serialization system: Powerful tools for data transformation
• Browsable API: Interactive API interface for easy testing
• Viewsets and routers: Reduces repetitive code

Example:

from rest_framework import viewsets
from rest_framework import permissions
from myapp.models import MyModel
from myapp.serializers import MyModelSerializer

class MyModelViewSet(viewsets.ModelViewSet):
    queryset = MyModel.objects.all()
    serializer_class = MyModelSerializer
    permission_classes = [permissions.IsAuthenticated]

DRF remains the best choice for projects already using Django or those requiring a comprehensive set of features for complex API requirements.

TortoiseORM

While not a framework itself, TortoiseORM deserves mention as an excellent ORM designed specifically for async frameworks. It pairs perfectly with FastAPI, Litestar, or other ASGI frameworks.

Key features:

• Async-first design: Built for asynchronous applications
• SQLAlchemy-like syntax: Familiar to many Python developers
• Multiple database support: Works with PostgreSQL, MySQL, SQLite
• Migration support: Tools for database schema management

Example with FastAPI:

from fastapi import FastAPI
from tortoise.contrib.fastapi import register_tortoise
from tortoise import fields
from tortoise.models import Model

class User(Model):
    id = fields.IntField(pk=True)
    username = fields.CharField(max_length=50, unique=True)
    
    class Meta:
        table = "users"

app = FastAPI()

register_tortoise(
    app,
    db_url="sqlite://db.sqlite3",
    modules={"models": ["__main__"]},
    generate_schemas=True,
    add_exception_handlers=True,
)

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    user = await User.get(id=user_id)
    return {"id": user.id, "username": user.username}

This combination is perfect for modern, high-performance API development with proper database integration.

Framework Comparison

To help you choose the right framework for your specific needs, here’s a comparison based on different use cases:

For High-Performance APIs

If raw performance is your primary concern, consider these options:

1. Litestar: Exceptional performance with comprehensive features
2. FastAPI: High performance with excellent developer experience
3. Starlette: Minimalist design focused on speed
4. BlackSheep: Modern ASGI design with high performance

For Rapid Development

When you need to develop quickly:

1. FastAPI: Type hints speed up development with automatic validation
2. Flask: Simple, intuitive API with minimal boilerplate
3. Litestar: Class-based controllers organize complex APIs effectively
4. Django REST Framework: Comprehensive toolkit reduces custom code

For Enterprise APIs

For large-scale, enterprise applications:

1. Django REST Framework: Comprehensive security, authentication, and permissions
2. Litestar: Strong typing, dependency injection, and ORM integration
3. FastAPI: Production-ready features with excellent performance
4. Django Ninja: Combines Django’s ecosystem with FastAPI-like features

For Microservices

When building microservices architecture:

1. FastAPI: Lightweight, high-performance, easy to containerize
2. Litestar: Strong typing and modular design fit microservices well
3. Falcon: Minimalist design ideal for focused microservices
4. Starlette: Core functionality without overhead

Performance Benchmarks

Performance is a critical factor when choosing an API framework. Based on recent TechEmpower Round 21 benchmarks, here’s how the frameworks compare:

Key insights from these benchmarks:

1. Rust-based frameworks like Robyn outperform Python natives by 20-25% in CPU-bound tasks
2. ASGI frameworks (FastAPI, Litestar) show dramatically better performance than WSGI counterparts
3. Memory efficiency correlates strongly with request handling capacity
4. Tail latency (99th percentile) shows even larger gaps than average performance

Note that performance benchmarks should be considered in context with your specific use case. For many applications, factors like developer productivity, ecosystem, and maintainability may be more important than raw performance.

Making Your Decision

When choosing a Python API framework, consider these factors:

1. Team experience: Leverage your team’s existing framework knowledge
2. Performance needs: Choose async frameworks for high-concurrency applications
3. Project complexity: More complex projects benefit from feature-rich frameworks
4. Integration requirements: Consider compatibility with your existing systems
5. Documentation needs: Some frameworks automate API docs better than others
6. Long-term maintenance: Consider community size and framework maturity

Selection Guide

Emerging Trends

AI-Powered Tools

AI integration is transforming API development:

• Code generation: AI assistants now scaffold API endpoints and suggest optimizations
• Security scanning: Automated detection of common vulnerabilities and anti-patterns
• Type inference: Enhanced static analysis for better type safety
• Query optimization: Automatic recommendations for database access patterns

GraphQL and Federation

GraphQL adoption continues to grow in the Python ecosystem:

• Strawberry (ASGI) leads in type-safe GraphQL implementations
• Ariadne remains popular for schema-first development
• Federation patterns enable microservice composition with unified GraphQL schemas

Authentication Trends

Modern API security emphasizes:

• OAuth2 passwordless flows with PKCE for mobile and SPA applications
• JWT token management with proper rotation and revocation
• Integrated RBAC (Role-Based Access Control) systems

Example of modern JWT validation in FastAPI:

from fastapi import FastAPI, Depends, HTTPException
from fastapi.security import OAuth2PasswordBearer
from jose import JWTError, jwt

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

async def get_current_user(token: str = Depends(oauth2_scheme)):
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        return User(**payload)
    except JWTError:
        raise HTTPException(status_code=401, detail="Invalid credentials")

Conclusion

The Python API framework landscape continues to evolve rapidly. We see a clear trend toward asynchronous, high-performance frameworks with strong typing and automatic documentation generation.

Strategic recommendations:

1. Adopt ASGI for all new projects requiring >1K requests per second
2. Implement automated OpenAPI documentation to reduce maintenance overhead
3. Evaluate Rust hybrids like Robyn when optimizing for p99 latency under 50ms
4. Consider AI-assisted development tools to accelerate compliant API creation

For new projects:

• FastAPI and Litestar stand out as excellent choices for modern API development
• Robyn shows promise for performance-critical applications
• Django REST Framework remains the best option for Django-based applications
• Flask and its extensions still offer simplicity and flexibility for simpler APIs

For existing projects, carefully evaluate the benefits of migration against the costs. Many older frameworks continue to receive updates and can be extended with modern features.

In the next part of this series, we’ll dive deeper into practical examples of building APIs with FastAPI and Litestar, complete with authentication, testing, and deployment considerations.

Good luck!

👍