---
id: aiometer
version: "1.0.0"
license: MIT
license_treatment: permissive
maintenance: aging
---

# aiometer — A Python concurrency scheduling library, compatible with asyncio and trio

License: permissive · Maintenance: aging · Downloads: 386.1K/mo

## What it is and what it does

aiometer is a concurrency scheduler for async Python that lets you run many tasks at once while controlling how many run simultaneously and how fast they spawn. It works with both asyncio and trio, making it easy to apply backpressure—slowing down task execution to avoid overwhelming servers, databases, or other resources.

The library provides four main entry points: run_on_each() for fire-and-forget execution, run_all() to collect results in order, amap() to process results as they complete, and run_any() to return the first successful result. You control concurrency with max_at_once (concurrent task limit) and max_per_second (spawn rate). It's fully type-annotated, has 100% test coverage, and supports Python 3.8 through 3.13.

Use it for:

- Make hundreds of HTTP requests concurrently without overwhelming the server by setting max_per_second and max_at_once limits.
- Run database queries in parallel while respecting connection pool limits via max_at_once.
- Process items from a queue with controlled concurrency to avoid resource exhaustion.
- Implement rate-limited API clients that respect per-second quotas.
- Coordinate async tasks across asyncio and trio codebases with a single scheduling interface.

## Worth the install?

AI-flagged interpretation of the facts above — verify before relying.

aiometer is a concurrency scheduling library that limits how many async tasks run simultaneously and controls their rate, working with both asyncio and trio.

Yes, if you need to manage concurrency in async code. The library is stable, has no known vulnerabilities, minimal dependencies, and solves a real problem—controlling task parallelism and rate. The aging maintenance (last release 497 days ago) is a minor concern but not a blocker given the stable status and active repository. Install it for production async workloads that need backpressure.

## Install

pip install aiometer
uv add aiometer
poetry add aiometer

## Installing aiometer

Before you install: Low friction: pure Python wheel with only two lightweight runtime dependencies (anyio and exceptiongroup). Maintenance is aging—last release was 497 days ago—but the repository remains active with recent commits and the package is marked Production/Stable.

License in practice: MIT license is permissive; you can use, modify, and distribute aiometer freely in commercial and private projects with minimal restrictions.

Quickstart:

import aiometer
import asyncio

async def task(item):
    await asyncio.sleep(0.1)
    return item

results = await aiometer.run_all(
    [task(i) for i in range(100)],
    max_at_once=10,
    max_per_second=5
)

Requires Python 3.8 or later; asyncio or trio must be available in your environment.

Verify before relying:

- Whether the aging maintenance status (497 days since last release) affects stability or security for new Python versions.
- Performance characteristics under very high concurrency (e.g., thousands of concurrent tasks).

## Package facts

- License: MIT (permissive)
- Python support: supports_current
- Install friction: low
- Maintenance: aging
- Downloads: 386.1K/month (top 15,000 on PyPI)
- Known vulnerabilities: none known

## Tags

async concurrency limiter, asyncio rate limiting, concurrent task scheduler, backpressure for async tasks, trio asyncio throttling, max concurrent tasks control, async flow control, async-concurrency, rate-limiting, backpressure

[View on SkillFed](https://skillfed.io/packages/aiometer) · [View on PyPI](https://pypi.org/project/aiometer/)