API Analytics

Monitoring and analytics for API frameworks.

Try now – it's free

Demo

Dashboard

A powerful all-in-one analytics dashboard. Real-time usage insight.

Open

Monitor

Active monitoring and error notifications. Peace of mind.

Open

Getting Started

Install

    pip install api-analytics[fastapi]

    pip install api-analytics[flask]

    pip install api-analytics[django]

    pip install api-analytics[tornado]

    npm install node-api-analytics

    npm install node-api-analytics

    npm install node-api-analytics

    npm install node-api-analytics

    go get -u github.com/tom-draper/api-analytics/analytics/go/gin

    go get -u github.com/tom-draper/api-analytics/analytics/go/echo

    go get -u github.com/tom-draper/api-analytics/analytics/go/fiber

    go get -u github.com/tom-draper/api-analytics/analytics/go/chi

    cargo add actix-analytics

    cargo add axum-analytics

    cargo add rocket-analytics

    gem install api_analytics

    gem install api_analytics

    dotnet add package APIAnalytics.AspNetCore

Add middleware to API

    import uvicorn
from fastapi import FastAPI
from api_analytics.fastapi import Analytics

app = FastAPI()
app.add_middleware(Analytics, api_key=<API-KEY>)  # Add middleware

@app.get('/')
async def root():
    return {'message': 'Hello, World!'}

if __name__ == '__main__':
    uvicorn.run('app:app', reload=True)

    from flask import Flask
from api_analytics.flask import add_middleware

app = Flask(__name__)
add_middleware(app, <API-KEY>)  # Add middleware

@app.get('/')
def root():
    return {'message': 'Hello, World!'}

if __name__ == '__main__':
    app.run()

    ANALYTICS_API_KEY = <API-KEY>

MIDDLEWARE = [
    'api_analytics.django.Analytics',
    ...
]

    import asyncio
from tornado.web import Application
from api_analytics.tornado import Analytics

# Inherit from the Analytics middleware class
class MainHandler(Analytics):
    def __init__(self, app, res):
        super().__init__(app, res, <API-KEY>)  # Provide api key
    
    def get(self):
        self.write({'message': 'Hello, World!'})

def make_app():
    return Application([
        (r'/', MainHandler),
    ])

if __name__ == '__main__':
    app = make_app()
    app.listen(8080)
    IOLoop.instance().start()

    import express from 'express';
import { expressAnalytics } from 'node-api-analytics';

const app = express();

app.use(expressAnalytics(<API-KEY>)); // Add middleware

app.get('/', (req, res) => {
    res.send({ message: 'Hello, World!' });
});

app.listen(8080, () => {
    console.log('Server listening at http://localhost:8080');
})

    import Fastify from 'fastify';
import { fastifyAnalytics } from 'node-api-analytics';

const fastify = Fastify();

fastify.addHook('onRequest', fastifyAnalytics(<API-KEY>)); // Add middleware

fastify.get('/', function (request, reply) {
    reply.send({ message: 'Hello, World!' });
})

fastify.listen({ port: 8080 }, function (err, address) {
    console.log('Server listening at http://localhost:8080');
    if (err) {
        fastify.log.error(err);
        process.exit(1);
    }
})

    import Koa from 'koa';
import { koaAnalytics } from 'node-api-analytics';

const app = new Koa();

app.use(koaAnalytics(<API-KEY>)); // Add middleware

app.use((ctx) => {
    ctx.body = { message: 'Hello, World!' };
});

app.listen(8080, () =>
    console.log('Server listening at http://localhost:8080');
);

    import { Hono } from 'hono';
import { serve } from '@hono/node-server';
import { honoAnalytics } from 'node-api-analytics';

const app = new Hono();

app.use('*', honoAnalytics(<API-KEY>));

app.get('/', (c) => c.text('Hello, world!'));

serve(app, (info) => {
	console.log('Server listening at http://localhost:' + info.port);
});

    package main

import(
    "net/http"
    "github.com/gin-gonic/gin"
    analytics "github.com/tom-draper/api-analytics/analytics/go/gin"
)

func root(c * gin.Context) {
    data := map[string]string{
        "message": "Hello, World!",
    }
    c.JSON(http.StatusOK, data)
}

func main() {
    r := gin.Default()
    
    r.Use(analytics.Analytics(<API-KEY>)) // Add middleware

    r.GET("/", root)
    r.Run(":8080")
}

    package main

import (
    "net/http"
    "github.com/labstack/echo/v4"
    analytics "github.com/tom-draper/api-analytics/analytics/go/echo"
)

func root(c echo.Context) error {
    data := map[string]string{
        "message": "Hello, World!",
    }
    return c.JSON(http.StatusOK, data)
}

func main() {
    e := echo.New()

    e.Use(analytics.Analytics(<API-KEY>))

    e.GET("/", root)
    e.Start(":8080")
}

    package main

import (
    "github.com/gofiber/fiber/v2"
    analytics "github.com/tom-draper/api-analytics/analytics/go/fiber"
)

func root(c *fiber.Ctx) error {
    data := map[string]string{
        "message": "Hello, World!",
    }
    return c.JSON(data)
}

func main() {
    app := fiber.New()

    app.Use(analytics.Analytics(<API-KEY>)) // Add middleware

    app.Get("/", root)
    app.Listen(":8080")
}

    package main

import (
    "encoding/json"
    "net/http"
    chi "github.com/go-chi/chi/v5"
    analytics "github.com/tom-draper/api-analytics/analytics/go/chi"
)

func root(w http.ResponseWriter, r *http.Request) {
    data := map[string]string{
        "message": "Hello, World!",
    }
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)

    err := json.NewEncoder(w).Encode(data)
    if err != nil {
        http.Error(w, "Failed to encode JSON", http.StatusInternalServerError)
        return
    }
}

func main() {
    r := chi.NewRouter()

    r.Use(analytics.Analytics(<API-KEY>)) // Add middleware

    r.GET("/", root)
    http.ListenAndServe(":8080", r)
}

    use actix_web::{get, web, App, HttpServer, Responder, Result};
use serde::Serialize;
use actix_analytics::Analytics;

#[derive(Serialize)]
struct JsonData {
    message: String,
}

#[get("/")]
async fn index() -> Result<impl Responder> {
    let data = JsonData {
        message: "Hello, World!".to_string(),
    };
    Ok(web::Json(data))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .wrap(Analytics::new(<API-KEY>))  // Add middleware
            .service(index)
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

    use axum::{
    routing::get,
    Json, Router,
};
use serde::Serialize;
use std::net::SocketAddr;
use tokio;
use axum_analytics::Analytics;

#[derive(Serialize)]
struct JsonData {
    message: String,
}

async fn root() -> Json<JsonData> {
    let data = JsonData {
        message: "Hello, World!".to_string(),
    };
    Json(data)
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .layer(Analytics::new(<API-KEY>))  // Add middleware
        .route("/", get(root));

    let addr = SocketAddr::from(([127, 0, 0, 1], 8080));
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await
        .unwrap();
}

    #[macro_use]
extern crate rocket;
use rocket::serde::json::Json;
use serde::Serialize;
use rocket_analytics::Analytics;

#[derive(Serialize)]
pub struct JsonData {
    message: String,
}

#[get("/")]
fn root() -> Json<JsonData> {
    let data = JsonData {
        message: "Hello, World!".to_string(),
    };
    Json(data)
}

#[launch]
fn rocket() -> _ {
    rocket::build()
        .mount("/", routes![root])
        .attach(Analytics::new(<API-KEY>))  // Add middleware
}

    require 'rails'
require 'api_analytics'

Bundler.require(*Rails.groups)

module RailsMiddleware
  class Application < Rails::Application
    config.load_defaults 6.1
    config.api_only = true

    config.middleware.use ::Analytics::Rails, <API-KEY> # Add middleware
  end
end

    require 'sinatra'
require 'api_analytics'

use Analytics::Sinatra, <API-KEY> # Add middleware

before do
    content_type 'application/json'
end

get '/' do
    {message: 'Hello, World!'}.to_json
end

    using analytics;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);

var app = builder.Build();

app.UseAnalytics(<API-KEY>); // Add middleware

app.MapGet("/", () =>
{
    return Results.Ok(new OkObjectResult(new { message = "Hello, World!" }));
});

app.Run();

Using Nginx?

Try Nginx Analytics, a flexible and fully self-hosted solution for real-time monitoring.

Get Started

FAQ

Outages