Catch Unprofitable Users.

Weckr tracks your real LLM cost per user, per feature and per call, so you see which customers cost more than they pay before the bill arrives.

Start for free See the live demo No credit card required
Downloaded 3,800+ times on npm and PyPI · Open source, MIT licensed
7.1 / 10OpenSSF Scorecard
OpenAI
Anthropic
Gemini
Kimi

Weckr is the margin layer for AI products. Wrap the client you already call and see cost, revenue and margin per user, per feature and per LLM call, as it happens.

This is the real dashboard on seeded data, not a screenshot. Every page is clickable.

Open the demo full screen

Your data never touches us. Your app never depends on us. Weckr sits beside your code, never in front of it. Metadata in, nothing sensitive out.

Your app
Your code, your prompts

Nothing leaves your server but the call you already make.

Weckr SDK, in your process
wk.chat(client, opts)

Wraps the client. Adds userId, feature, plan. Checks the cap.

LLM provider
OpenAI · Anthropic · Gemini · Kimi

The same request as before. Zero added latency.

After the response returns

One async POST to Weckr with tokens, cost, latency, and the userId you passed. Never the prompt, never the reply. If Weckr is unreachable, the log is dropped and your call already succeeded.

Prompts never leave your server

Weckr logs tokens, cost, latency, and the userId you pass in. Prompt and response text are never sent.

Out of the request path

Your LLM calls go straight to the provider. Weckr logs asynchronously, with zero added latency.

Fails open, always

If Weckr is unreachable, your app keeps working. Logging fails silently and calls are never blocked.

Open source, verify everything

The full SDK is MIT licensed on GitHub. Read every line, and remove it by unwrapping one client.

Your heaviest users are often your least profitable. A user on your $9 starter plan who hits your AI features 50 times a day can cost you $40 a month to serve. They look engaged. They are your most expensive liability, and you will not know until the OpenAI bill arrives.

Live spend by user, model and feature

Every call logs the moment it returns, priced at current rates.

Margin per user

Plan revenue minus real AI cost, per customer, per period.

Worst margin always on top

One sort on the Users page finds the customer costing more than they pay.

An agent loop can burn tokens all night. Weckr flags it in minutes. Alerts fire the moment a user crosses 50,000 tokens in five minutes, in your own Slack and email. Caps bound what any user can cost you, checked before every call, whether or not anyone is awake.

Alerts
  • Agent loop detection

    Sums tokens per user over a rolling window. Cross 50,000 tokens in 5 minutes and we Slack you immediately.

  • Margin alerts

    Set a negative-margin threshold per project. When a user drops below it, we ping Slack and email. Cooldown prevents spam.

  • Weekly digest

    Optional Monday 09:00 UTC email: cost, revenue, margin, top users, top features, week-over-week.

Spending caps

Set a monthly cap per plan. The SDK checks it before every LLM call. On a hit you choose: silently downgrade to a cheaper model, or throw WeckrCapError and show your own upgrade prompt. Fails open if we are down.

import { isWeckrCapError } from '@weckr/sdk';

try {
  await wk.chat(openai, opts);
} catch (err) {
  if (isWeckrCapError(err)) return upgradePrompt();
  throw err;
}

No Slack OAuth or app install. You paste an incoming webhook URL and we POST to it. Same pattern Sentry and Linear use.

Beside your code, not between you and your provider. Most observability tools proxy the call and store the prompt. Weckr wraps the client, keeps the metadata, and enforces the budget.

Where it sits
Most LLM tools proxy your calls. You swap your base URL or rotate keys.
An SDK that wraps your existing client. No DNS change, no SLA on your critical path.
What it measures
Most tools group cost by request or session. Useful for traces, useless for margin.
Cost grouped by user and plan. You see exactly which customer costs more than they pay.
What it does
Most tools observe and report. They tell you the bill once it has already run up.
Enforces. Caps block or downgrade the call before the model bills you for it.
What it keeps
Most tools capture full prompts and responses to power traces and replays.
Metadata only: tokens, model, latency, cost. No prompt body ever leaves your server.

Wrap your client. Or let Claude do it. Two lines in TypeScript or Python. Or paste one prompt and let Claude wire Weckr into your codebase end to end.

$ npm install @weckr/sdk
// before
const result = await openai.chat.completions.create(opts);
// after @weckr/sdk
import { Weckr } from '@weckr/sdk';
const wk = new Weckr({ apiKey: 'wk_…', plans: { pro: 29 } });

const result = await wk.chat(openai, { ...opts, userId, feature, plan });

Two added lines in app.ts. Logs fire after your LLM call returns, with zero added latency.

One flat price, no usage math. Free for your first 50,000 requests a month. Pro is $49 flat, seven days free, cancel from the dashboard whenever you like.

Hobby

$0/mo

Up to 50k requests a month. For founders shipping their first AI feature.

  • Per-user cost and margin view
  • 90-day log retention
  • Basic cost analytics
Get started for free

Pro

Most popular
$49/mo

Up to 1M requests a month. 7 days free, then $49. Cancel anytime.

  • Everything in Hobby
  • Spending caps: block or downgrade
  • Loop detection and Slack alerts
  • Model and pricing recommendations
  • Unlimited log retention
Start 7-day free trial

No card up front. No usage meter running. Beta launch pricing, locked in for early adopters. A single runaway agent left looping overnight can cost more than a year of Pro.

Prefer a walkthrough over exploring solo? Thirty minutes with the founder. Weckr wired into your actual app, live, and every question about cost, margin, caps or safety answered. No slides, just your code.

Book a demo
Ghiles Asmani
The founder

Ghiles Asmani

Founder · Stockholm, Sweden

AI engineer in Stockholm, working as a consultant on production LLM systems. Across multiple projects I kept running into the same problem: a handful of users were quietly costing more in OpenAI calls than they paid in subscription, and nobody noticed until the invoice arrived. I looked for an off-the-shelf tool that catches it in real time. There wasn't one, so I built Weckr.

LinkedInGitHub

Common questions. Straight answers on data, latency, providers, caps and price.

Those dashboards give you one number for the whole account. Weckr splits that number by user, so you can see who actually earns their keep and who quietly costs you more than they pay. A single total hides the customer draining your margin.

Never. The SDK sends metadata and nothing else: token counts, the model, latency, and the userId and feature you tag the call with. Your prompts and the model replies stay on your server. We could not read them if we tried.

No. Your call goes straight to the provider like it always did. Weckr sends its log after the response comes back, in the background, so nothing waits on us.

OpenAI, Anthropic, Gemini, and Kimi (Moonshot AI) right now. If you build on LangChain or CrewAI, there are docs for wiring Weckr in. More are on the way.

Your app does not notice. We sit off to the side of your request, so your model calls never wait on us or need us. If we go dark, logging pauses and picks back up when we return. Nothing breaks.

Free for your first 50000 requests a month. After that Pro is 49 dollars a month, flat, and it lifts your limit to 1 million requests a month, with spending caps, loop detection, and model recommendations. We never bill by usage, so the number never sneaks up on you.

Totally depends on the model. Push 50,000 requests through something cheap like gpt-5.4-nano and you might spend around $10. Push the same 50,000 through a frontier model like GPT-5.6 or Claude Opus and it can be $300 or more. Same request count, roughly thirty times the bill. That gap is the whole reason one spend number tells you almost nothing, and why Weckr breaks it down by user and by model.

Yes, and you set it in the dashboard without touching code. Pick what happens when someone hits their cap: block the call outright, or quietly drop them to a cheaper model so the feature keeps working.

When one user session burns more than 50000 tokens in 5 minutes, Weckr pings your Slack right away. That is usually an agent stuck looping on itself, and catching it in minutes instead of at invoice time is the difference between a shrug and a scary bill.

Yes. The whole SDK is MIT licensed and sitting on GitHub, so you can read every line that runs inside your app. If you ever change your mind, pulling it out is one unwrapped client, about 10 minutes of work.