Codeskop for Python

Codeskop is crash, error and API monitoring for mobile, web and backend apps. Get started free at www.codeskop.com.

codeskop is the Python SDK for Codeskop. Add it to a Django, Flask, FastAPI or Celery app and Codeskop groups its errors into issues with stack traces, records every request it handles by route, and shows which outgoing API calls fail or slow down, next to the crashes and network calls from your mobile and web apps.

• Errors: unhandled exceptions in web requests, threads, Celery tasks and the main thread, plus capture_exception(), capture_message() and a logging handler. Grouped by your own code, so library frames don't split issues.
• Incoming requests: every request your app handles, by route (/orders/{pk}/), with status, latency and size.
• Outgoing calls: requests and httpx calls to other APIs, with status, latency and failures.
• Light and safe: no dependencies. It never blocks a request: events are batched, compressed and sent in the background, with retries. Every public function is safe to call before init and never raises into your code.

Works with Django 3.2+, Flask 2.2+, FastAPI and Starlette, Celery 5+, requests and httpx. Python 3.9 and later.

Get started in 2 minutes

1. Create a free account at dashboard.codeskop.com/signup. No credit card. Every project has a Test key (cs_test_pk_…) and a Live key (cs_live_pk_…); copy one from API tokens.

2. Install:

pip install codeskop        # or: poetry add codeskop / uv add codeskop

3. Set your key (Test key locally, Live key in production):

export CODESKOP_API_KEY=cs_test_pk_…

4. Initialize once, as early as possible:

import codeskop

codeskop.init()   # reads CODESKOP_API_KEY; or codeskop.init(api_key="cs_live_pk_…")

On its own this captures unhandled exceptions in the main thread and other threads, and outgoing requests / httpx calls. Add your framework below to record requests too. Raise an exception and it shows up in your dashboard a few seconds later.

Frameworks

Django

# settings.py
import codeskop

codeskop.init()

MIDDLEWARE = [
    "codeskop.integrations.django.CodeskopMiddleware",  # near the top
    "django.middleware.security.SecurityMiddleware",
    # ...
]

Routes come from your URL patterns (/orders/{pk}/), and the signed-in user's primary key is attached automatically.

Flask

from flask import Flask
import codeskop
from codeskop.integrations.flask import CodeskopFlask

codeskop.init()

app = Flask(__name__)
CodeskopFlask(app)   # in an app factory: CodeskopFlask().init_app(app)

Routes come from your URL rules. Uses g.user_id or Flask-Login's current_user when present.

FastAPI and Starlette

from fastapi import FastAPI
import codeskop
from codeskop.integrations.asgi import CodeskopMiddleware

codeskop.init()

app = FastAPI()
app.add_middleware(CodeskopMiddleware)

Routes come from the matched path (/items/{item_id}). Set request.state.user_id in your auth dependency to attach users.

Celery

import codeskop
from codeskop.integrations import celery as codeskop_celery

codeskop.init()
codeskop_celery.install()   # task failures, tagged with the task name

Task failures are reported with the task name and ID as tags, and events are flushed after each task.

Common tasks

import logging
import codeskop

# Report a handled error, with optional tags.
try:
    charge(order)
except PaymentError as exc:
    codeskop.capture_exception(exc, tags={"provider": "stripe"})

codeskop.capture_message("Inventory sync skipped", severity="medium")

# Attach events in this request to a user (your own ID, never an email).
codeskop.set_user(request.user.pk)

# Send ERROR (and above) log records to Codeskop.
logging.getLogger().addHandler(codeskop.LoggingHandler())

Workers, forking and serverless

Gunicorn, uWSGI and other pre-fork servers work as they are: each worker process starts its own sender, and events left in memory are sent when the process exits normally. On AWS Lambda or Cloud Functions, flush at the end of each invocation:

def handler(event, context):
    try:
        return process(event)
    finally:
        codeskop.flush(2)   # send before the runtime freezes

What's captured automatically

• Unhandled exceptions in the main thread, other threads, web requests (with the route) and Celery tasks.
• Every incoming request by route, with method, status, latency and size, once your framework integration is added. Find them on the Network page under Requests your servers receive. Health checks (/health*, /healthz, /metrics, /favicon.ico) aren't recorded.
• Outgoing requests and httpx calls, on the Network page under APIs your apps call.
• Users from Django's signed-in user, Flask's g.user_id / Flask-Login, or request.state.user_id on FastAPI.
• Release, detected from CODESKOP_RELEASE or the commit on Render, Heroku, Vercel, Railway, Cloud Run and GitHub Actions.

API keys and environments

Server SDKs use the project's public key, the same kind of key your mobile and web apps use. Public keys can only send events, never read your data.

Set it as CODESKOP_API_KEY in each environment and the SDK reads it on its own, or pass codeskop.init(api_key=…) in code. Never put a secret key (cs_…_sk_…) in a service: the SDK refuses it and stays switched off, without throwing. A missing or malformed key does the same, so if nothing shows up, check the key first. The key decides which environment events land in; the environment option is a label shown on events.

Create a separate Codeskop project for each backend service so its issues and routes stay apart. More: Core concepts and server SDK keys.

Configuration

Pass options as keyword arguments to codeskop.init().

def scrub(event):
    if event["type"] == "exception" and "card" in event["payload"].get("message", ""):
        event["payload"]["message"] = "[scrubbed]"
    return event          # or None to drop it

codeskop.init(before_send=scrub)

Plans

The SDK is the same on every plan; your plan decides what's kept. Request and API call monitoring follow the network monitoring on your plan, with the same sampling, and failed requests are always kept. See pricing.

Privacy

Never captured: request or response bodies, cookies, Authorization headers and query strings. Requests are recorded by route template, so IDs in the path don't become separate routes.

What is sent: the error type, message and stack trace; for each request, the method, route, status, latency and size; for outgoing calls, the method, host, path, status and latency. Each event also carries your environment and release, plus the host name, OS and runtime version of the server.

You choose the user ID. Pass your own ID, never an email address or phone number.

Error messages are sent as written. If yours can contain personal data, scrub or drop events with before_send, or skip error types with ignore_exceptions.

Codeskop also redacts payload fields named like secrets (password, token, api_key, card number…) on the server.

Details: Privacy & Security.

Troubleshooting

• Initialize with debug=True and look for codeskop log lines.
• Check you used the public key (_pk_) of the project and environment you're viewing.
• Incoming requests need network monitoring on your plan (Starter and up). Errors work on every plan.
• Short scripts: call codeskop.flush() before exiting.

More: Troubleshooting.

Documentation

• Python guide
• Server SDKs overview
• Privacy & Security
• Changelog

Other Codeskop SDKs

Monitor your mobile apps, web apps and backend services in one dashboard:

Help

Questions or a bug? Contact us, email support@codeskop.com, or open an issue in this repository.

Development

python -m venv .venv && .venv/bin/pip install -e ".[test]"
.venv/bin/pytest

The test suite runs against a local mock of the ingest API (tests/conftest.py).

License

MIT