reqly

API monitoring for Python that tells you what broke, when, and which deploy did it.
FastAPI · Flask · Django · Starlette · Litestar · any WSGI/ASGI app, in one line.

Documentation · Quickstart · Live demo · GitHub

Install

pip install reqly

import reqly
from fastapi import FastAPI

app = FastAPI()
reqly.instrument(app, service_name="checkout-api",
                 collector_url="https://reqly.example.com", api_key="your-ingest-key")

That's it: every route now reports its latency, errors, status codes and release to your own Reqly collector. No decorators, no agent, no vendor account.

What you get

Your framework

# settings.py (Django)
MIDDLEWARE = ["reqly.integrations.django.ReqlyMiddleware", ...]
REQLY = {"service_name": "checkout-api", "api_key": "your-ingest-key"}

# Bottle: tell Reqly where the route template is
app = reqly.instrument_wsgi(app, service_name="checkout-api",
                            route_resolver=lambda environ: environ["bottle.route"].rule)

Routes are recorded as templates (/users/{id}), never raw paths; requests no route matched become __unmatched__, so 404 scanners can't flood your data.

Who is calling, and what it costs

reqly.instrument(app, consumer_header="X-API-Key", consumer_salt=os.environ["REQLY_CONSUMER_SALT"])

completion = client.chat.completions.create(model="gpt-4o-mini", messages=messages)
reqly.record_llm_response(completion)          # OpenAI / Anthropic responses, or:
reqly.record_llm_usage("gpt-4o-mini", input_tokens=1200, output_tokens=240)

Consumer ids are HMAC-SHA256-hashed with your salt before they leave the app; the collector never sees an API key.

An alert looks like this

🔴 Anomaly — flask-demo /orders (Friday 15:00-16:00 UTC, z=5.37)
• error rate 30.0% vs 2.2% usual · p95 6588ms vs 1576ms usual
• running release v2 — vs v1: errors 2.6% → 33.1%, p95 2072ms → 4501ms
• 100% of errors came from host pod-3, which served 23% of requests

Configuration

Pass options to instrument() or set environment variables (argument → environment variable → default).

Every option, explained: Python SDK docs.

Built to stay out of your way

• ⚡ ~13 µs per request on FastAPI and Starlette, ~33 µs on Flask (benchmark)
• 🛡️ Fail-open: an internal error is logged once and instrumentation turns itself off; it never raises into your app
• 🧵 Off the request path: a background thread ships batches with strict timeouts, so a slow collector never blocks a request
• 📦 Bounded: a fixed-size queue (oldest dropped first) and route templates only
• 🔁 Safe retries on 408, 429 and 5xx, deduplicated by the collector
• ⏱️ Bounded exit: queued events are sent on shutdown in at most 5 s, so a collector outage never holds up a deploy
• 🍴 Pre-fork servers (gunicorn --preload, uWSGI) restart the shipper in each worker

Compatibility

Not on Python? There's a Node.js SDK, and any language can report through OpenTelemetry.

Run the collector

The SDK sends to a Reqly collector you host (TimescaleDB + collector + dashboard):

git clone https://github.com/tanisheesh/reqly && cd reqly && docker compose up -d
# or on Kubernetes
helm install reqly oci://ghcr.io/tanisheesh/charts/reqly -n reqly --create-namespace

Quickstart · Deploy to production · Changelog · License: MIT (the collector is AGPL-3.0)