API observability platform · in public beta

Observeeveryrequest

Kivia is a lightweight platform that captures every HTTP request your APIs serve — keys, latency, status codes, paths — and surfaces them in a live dashboard you can read at a glance.

Get started free

A first-class
developer experience.

Integrate Kivia in minutes. Native SDKs for Go and JavaScript — works with Express, Hono, Fastify, and Elysia. Zero config, zero overhead, zero ceremony.

/ 01

Online in three lines

Create a client, wrap your handler, and Kivia captures everything automatically.

go
client := kiviasdk.NewClient("kivia_sk_...")
handler := client.NewLog(mux)
http.ListenAndServe(":8080", handler)
/ 02

Instant observability

Watch live traffic, statuses, and latency in the dashboard.

stream
POST /auth/login            200  45ms
GET  /api/v1/projects/all   200  12ms
POST /api/v1/logs/create    201   8ms
GET  /api/v1/logs/all/abc   200   3ms
/ 03

API key management

Create and revoke keys per project. Keys are hashed and stored securely.

keys
Name        Key              Status
production  kivia_sk_a3f•••  ● Active
staging     kivia_sk_7x2•••  ● Active
deprecated  kivia_sk_old•••  ○ Revoked
/ 04

Multi-project support

Scope keys and logs per project. Ideal for microservice architectures.

projects
production-api    3 keys   12,847 reqs
staging-api       2 keys    1,203 reqs
internal-tools    1 key       456 reqs

Up and running
in minutes, not days.

01→ next

Install SDK

Add Kivia to your Go or JavaScript project.

›go get / npm install
02→ next

Create API key

Generate a key in the dashboard for your project.

›kivia_sk_...
03→ next

Add middleware

One line captures every request automatically.

›client.middleware()
04● final

View dashboard

See live traffic, latency, and status codes instantly.

›dashboard >

Drop-in
middleware for
any backend.

Lightweight SDKs that wrap your existing HTTP handlers. No refactoring, no config files. Import and observe.

  • 01Zero-config request capture
  • 02Automatic latency measurement
  • 03Async log shipping (no overhead)
  • 04Status code & path extraction
main.go
Go
package main

import (
    "net/http"
    "github.com/kivia-observe/kivia-sdk-go"
)

func main() {
    // Initialize the client
    client := kiviasdk.NewClient(
        "kivia_sk_your_key",
    )

    // Wrap your handler — that's it
    handler := client.NewLog(mux)

    http.ListenAndServe(":8080", handler)
}

Everything you need.
Nothing you don't.

01

Real-time monitoring

Watch every API request as it happens with live-updating logs and status indicators.

live · sse
02

API key management

Generate, rotate, and revoke API keys with fine-grained per-project control.

hashed · scoped
03

Latency analytics

Pinpoint slow endpoints with detailed latency breakdowns and percentile tracking.

p50 · p95 · p99
04

Drop-in SDK

Three lines of code. Works with Express, Hono, Fastify, Elysia, and Go out of the box.

5 runtimes
05

Per-project scoping

Isolated keys and logs per project. Perfect for multi-service architectures.

isolated
06

Historical logs

Query past requests by date range, status code, and path with full context.

queryable
01 / 03
< 2min

Integration time

From npm install to first capture.

02 / 03
< 1ms

Middleware overhead

Async log shipping. Non-blocking.

03 / 03
100%

Request capture rate

Every request. Every status. Every path.

/ Begin transmission

Ready to see what
your APIs are doing?

Create free accountSign in