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.
Product
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
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
Send one numeric event with JavaScript, Python, Go, or raw HTTP. Chirpier creates the event definition and starts recording the stream immediately.
02
Read analytics for the event and compare the current minute, hour, or day against the previous period using the API or SDKs.
03
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
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
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.
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
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
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 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.
Send flat numeric events with JavaScript, Python, Go, or raw HTTP using the same bearer token model across ingestion and control-plane APIs.
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.
Turn one event into policies, alert destinations, public dashboards, and embeddable widgets without re-modeling it in another system.
Dashboard and sharing
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
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
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.
Inspect minute, hour, and day history or compare the current window against the previous one without building your own aggregation layer.
Turn the same monitored event into a hosted public page or a focused embedded view when other people need to see the trend.
Create threshold policies and route alerts to OpenClaw, Slack, Discord, Telegram, e-mail, or webhooks with delivery history when setup needs debugging.
Alerts
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.
Create threshold rules on sums, averages, percentiles, mins, and maxes so count, duration, score, and value streams behave the way operators expect.
Route alerts to OpenClaw, Slack, Discord, Telegram, e-mail, or generic webhooks, then inspect test sends and real deliveries when setup needs debugging.
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
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.