Flaxon

Author: Aldane Hutchinson

Flaxon is an async-first ASGI framework for JSON APIs, WebSockets, and server-rendered applications. It provides the HTTP boundary; you choose the database, frontend, queue, and deployment platform.

Status: Production/stable.

Install

Flaxon requires Python 3.11 or newer.

pip install "flaxon[standard]"

standard installs the recommended ASGI server and template dependencies. For framework development, install pip install -e ".[standard,dev]" instead.

Your first API

Create app.py:

from flaxon import Flaxon

app = Flaxon("hello-api", debug=True)


@app.get("/")
async def home():
    return {"message": "Hello from Flaxon"}


@app.get("/users/<int:user_id>")
async def get_user(user_id: int):
    return {"id": user_id, "name": "Example User"}

Start the development server:

flaxon run app:app --reload

Open http://127.0.0.1:8000/. For a production process, use flaxon run without --reload or run the same ASGI application with Uvicorn.

Validate JSON input

Use Schema parameters for JSON request bodies. Field names use the full *Field spelling.

from flaxon.validation import Schema, fields


class CreateUser(Schema):
    name = fields.StrField(required=True, min_length=2, max_length=80)
    email = fields.EmailField(required=True)
    age = fields.IntField(minimum=13, maximum=120)


@app.post("/users")
async def create_user(data: CreateUser):
    return {"user": data.to_dict()}

Available field classes are StrField, IntField, FloatField, BoolField, EmailField, DateField, DateTimeField, DecimalField, UUIDField, ListField, ChoiceField, NestedField, and AnyField.

WebSockets

from flaxon.websocket import WebSocket


@app.websocket("/ws/chat/<room_id>")
async def chat(socket: WebSocket, room_id: str):
    await socket.accept()
    await socket.join(room_id)
    try:
        async for message in socket.iter_json():
            await socket.broadcast_json(room_id, {"event": "chat.message", "data": message})
    finally:
        await socket.leave(room_id)

The default room manager is in-process. Use shared infrastructure for cross-worker or multi-instance broadcasts.

Server-rendered HTML with Jinax

Install the template extra if it is not already included through standard:

pip install "flaxon[templates]"

from flaxon.jinax import Jinax

app.use_templates(Jinax("templates", auto_reload=True))


@app.get("/")
async def home(request):
    return await request.render("home.html", {"title": "Welcome"})

Jinax uses Jinja2 autoescaping for HTML templates. Only mark content safe when it has been produced by a trusted sanitizer.

What Flaxon includes

• HTTP routing, typed path parameters, request parsing, responses, and streams.
• Schema validation and validation decorators.
• Middleware for CORS, request IDs, security headers, trusted hosts, body limits, compression, logging, recovery, sessions, and timeouts.
• Sessions, JWT, API keys, authentication, roles, permissions, CSRF, and rate limiting.
• WebSocket routes, JSON messaging, rooms, and broadcast helpers.
• Jinax templates, caching helpers, database adapters/transactions, background tasks, plugins, OpenAPI, GraphQL, health checks, and metrics.
• TestClient and AsyncWebSocketClient for application tests.

Documentation and examples

• Documentation home
• Quick start
• Growing a 200-page application
• Deployment
• Security
• Examples

The runnable example applications live in docs/examples/: a basic API, React backend, Android backend, and Jinax site.

Production checklist

• Set DEBUG=False and a strong FLAXON_SECRET_KEY.
• Use explicit allowed origins and trusted hosts.
• Run multiple workers only after moving shared state (sessions, cache, task coordination, and WebSocket fan-out) to durable/shared infrastructure.
• Run behind TLS and a reverse proxy or managed load balancer.
• Add database migrations, backups, health checks, metrics, structured logs, and load tests for your deployment topology.

See the deployment guide for the complete checklist.

Contributing

git clone https://github.com/aldanedev-create/Flaxon-Backend-Framework.git
cd Flaxon-Backend-Framework
python -m venv .venv
# Activate the environment, then:
pip install -e ".[standard,dev]"
pytest

Flaxon is released under the MIT License.