SDKs & Client Libraries

# Not yet on npm — clone or Download ZIP and install from source:
git clone https://github.com/aforoai/SDKs.git
cd SDKs/aforo-metering-sdks/node
npm install && npm run build && npm pack
# then in your app:
npm i /path/to/aforo-metering-1.0.0.tgz

import { AforoClient } from '@aforo/metering';

const aforo = new AforoClient({ apiKey: process.env.AFORO_API_KEY });

// Count one billable action — non-blocking, flushes in the background
await aforo.track({
  customerId: 'cust_123',
  metricName: 'api_calls',
  quantity: 1,
});

// Flush remaining events before the process exits:
await aforo.shutdown();

import { expressMiddleware } from '@aforo/metering/middleware/express';

// Meters every request after the response is sent — zero added latency
app.use(expressMiddleware({
  apiKey: process.env.AFORO_API_KEY,
  customerId: (req) => req.user?.id ?? null,  // return null to skip metering
}));

# Not yet on PyPI — clone and install from source:
git clone https://github.com/aforoai/SDKs.git
cd SDKs/aforo-metering-sdks/python
pip install -e .            # or: pip install -e ".[fastapi]"

import os
from aforo import AforoClient

client = AforoClient(api_key=os.environ["AFORO_API_KEY"])

client.track(
    customer_id="cust_1",      # who is billed
    metric_name="api_calls",   # what you're metering
    quantity=1,
)

# Force a synchronous flush when you need delivery confirmed:
result = client.flush()        # FlushResult(sent=..., failed=...)
client.shutdown()              # also registered via atexit

# FastAPI / Starlette
from aforo.middleware.fastapi import AforoMeteringMiddleware
app.add_middleware(AforoMeteringMiddleware, api_key=os.environ["AFORO_API_KEY"])

# Flask
from aforo.middleware.flask import AforoMetering
AforoMetering(app, api_key=os.environ["AFORO_API_KEY"])

# Django settings.py
MIDDLEWARE = [..., "aforo.middleware.django.AforoMeteringMiddleware"]
AFORO_API_KEY = os.environ["AFORO_API_KEY"]

# Resolves once the first Go module tag is pushed. Until then, clone + replace:
git clone https://github.com/aforoai/SDKs.git

require github.com/aforoai/SDKs/aforo-metering-sdks/go v1.0.0

replace github.com/aforoai/SDKs/aforo-metering-sdks/go => ../SDKs/aforo-metering-sdks/go

package main

import (
    "net/http"
    "os"

    metering "github.com/aforoai/SDKs/aforo-metering-sdks/go"
)

func main() {
    client := metering.NewClient(metering.Options{
        APIKey:  os.Getenv("AFORO_API_KEY"),
        BaseURL: "https://ingest.aforo.ai", // default
    })
    defer client.Close() // flushes the buffer before exit

    // Manual track when you know an event happened:
    client.Track(metering.TrackEvent{
        CustomerID: "cust_acme_001",
        MetricName: "api_calls",
        Quantity:   1,
    })

    // Or meter every request — reads X-Customer-Id, emits after the response:
    mux := http.NewServeMux()
    wrapped := metering.HTTPMiddleware(mux, metering.MiddlewareOptions{
        APIKey: os.Getenv("AFORO_API_KEY"),
    })
    http.ListenAndServe(":8080", wrapped)
}

<dependency>
  <groupId>com.aforo</groupId>
  <artifactId>metering</artifactId>
  <version>1.0.0</version>
</dependency>

# Not yet on Maven Central — build from source into your local ~/.m2:
git clone https://github.com/aforoai/SDKs.git
cd SDKs/aforo-metering-sdks/java
mvn clean install

import com.aforo.metering.AforoClient;
import com.aforo.metering.AforoOptions;
import com.aforo.metering.TrackEvent;

// AforoClient is AutoCloseable — the buffer flushes on close
try (AforoClient client = new AforoClient(new AforoOptions(System.getenv("AFORO_API_KEY")))) {
    client.track(TrackEvent.builder("cust_acme_001", "api_calls")
            .quantity(1)
            .metadata(java.util.Map.of("route", "POST /v1/charges"))
            .build());
}

aforo:
  enabled: true          # auto-config is off unless this is exactly "true"
  api-key: ${AFORO_API_KEY}
  base-url: https://ingest.aforo.ai