Product

From one event payload to live monitoring, alerting, and sharing

Chirpier turns numeric operational events into managed monitoring surfaces your team can inspect, compare, alert on, share publicly, and embed elsewhere without building the stack yourself.

How it works

One event, four jobs

Chirpier is built around one simple operating loop: send an event, compare it to the previous period, trigger workflows when thresholds are crossed, and share the live dashboard with the people who need to see it.

01

Log an event

Send one numeric event with JavaScript, Python, Go, or raw HTTP. Chirpier creates the event definition and starts recording the stream immediately.

02

Compare the signal

Read analytics for the event and compare the current minute, hour, or day against the previous period using the API or SDKs.

03

Add alert policies and destinations

Create threshold policies and route alerts to OpenClaw, Slack, Discord, Telegram, e-mail, or webhooks when the signal crosses the line you care about.

04

Share the live dashboard

Send teammates, operators, or customers to the hosted public page so they can follow the trend without needing access to the private workspace.

How little code it takes

The main Chirpier loop fits into a few focused snippets

These examples are pulled from the same paths Chirpier documents today: quick start for logging, the analytics API for comparisons, chirpier-skills for OpenClaw workflows, and the hosted chart client for public sharing.

Send one event with a few lines of code

This is the fastest path from the quick start: send a numeric event and Chirpier creates the event definition automatically.

Quick start

JavaScript

import { createClient } from "@chirpier/chirpier-js"

const client = createClient({
  key: process.env.CHIRPIER_API_KEY,
})

await client.log({
  agent: "checkout-service",
  event: "checkout.failed",
  value: 1,
  occurred_at: new Date(),
})

await client.shutdown()

Go

ctx := context.Background()

client, _ := chirpier.NewClient(chirpier.Options{
  Key: os.Getenv("CHIRPIER_API_KEY"),
})
defer client.Close(ctx)

_ = client.Log(ctx, chirpier.Log{
  Agent: "checkout-service",
  Event: "checkout.failed",
  Value: 1,
  OccurredAt: time.Now().UTC(),
})

Python

from chirpier import Log, new_client
from datetime import datetime, timezone
import os

client = new_client(api_key=os.environ["CHIRPIER_API_KEY"])

client.log(Log(
    agent="checkout-service",
    event="checkout.failed",
    value=1,
    occurred_at=datetime.now(timezone.utc),
))

client.close()

Live proof

Send one event and Chirpier gives you a live monitoring surface

This is the payoff of the flow: one event stream becomes a live dashboard your team can inspect, compare, alert on, and share without first building a separate analytics stack.

dashboard / events

Page views

Change the monitoring window, click to add a page view event, and watch the embed update. Click here to view dedicated event dashboard.

Why it stays simple

The core loop works because Chirpier keeps everything on the same event definition

The same event stream powers ingestion, comparisons, policy evaluation, destination routing, public pages, and embeds. Teams do not need to remodel the signal in separate tools at each step.

Ingest with one simple payload shape

Send flat numeric events with JavaScript, Python, Go, or raw HTTP using the same bearer token model across ingestion and control-plane APIs.

Check what changed against the previous period

As soon as data lands, Chirpier gives the event comparison-ready analytics so teams can quickly see whether a signal is rising, falling, or moving outside its recent pattern.

Use the same monitoring surface for alerts and sharing

Turn one event into policies, alert destinations, public dashboards, and embeddable widgets without re-modeling it in another system.

Dashboard and sharing

Give your team the private workspace, then give everyone else the live view

Teams investigate and operate from the authenticated dashboard, then share the exact public page or embedded view that customers, operators, or teammates need.

inside the product

The event stays the center of the workflow

Inspect the event in the dashboard, read minute, hour, or day rollups, compare windows, create an alert policy, test a destination, and then share or embed the same signal without rebuilding a dashboard model each time.

internal

Authenticated event workspace

Browse events, inspect rollups, compare windows, and manage policies, alerts, and destinations in one private workspace.

external

Public pages and focused embeds

Expose only the event view you need, whether that is a hosted page, a single summary, or a focused widget inside another product surface.

Private event workspaces for teams who need to inspect and operate live signals

Public event pages when customers, operators, or partners need focused visibility

Focused embeds for internal tools, product dashboards, and workflow surfaces

Comparisons

Check what changed, not just what happened

Use the analytics API or SDKs to compare the current minute, hour, or day to the previous period so teams can quickly tell whether a signal is moving outside its recent pattern.

Period-over-period comparisons

Inspect minute, hour, and day history or compare the current window against the previous one without building your own aggregation layer.

Hosted public pages and embeds

Turn the same monitored event into a hosted public page or a focused embedded view when other people need to see the trend.

Operational alert routing

Create threshold policies and route alerts to OpenClaw, Slack, Discord, Telegram, e-mail, or webhooks with delivery history when setup needs debugging.

Alerts

Turn thresholds into actions

Create policies on the same event stream you inspect every day, then route alerts to OpenClaw, Slack, Discord, Telegram, e-mail, or webhooks when thresholds are exceeded.

Policies that match the stream shape

Create threshold rules on sums, averages, percentiles, mins, and maxes so count, duration, score, and value streams behave the way operators expect.

Destinations with test and delivery history

Route alerts to OpenClaw, Slack, Discord, Telegram, e-mail, or generic webhooks, then inspect test sends and real deliveries when setup needs debugging.

A tighter loop from signal to response

Keep the event page, policy, alert lifecycle, and outbound routing tied to the same stream so teams can investigate and act with less context switching.

Try the product

Start with one event and see the whole Chirpier loop

Create an account, send a test event, inspect the comparison views, add a policy, route alerts to a destination, and share the public dashboard when the signal is ready.