Know which customers are quietly unprofitable before the bill arrives.

See which customers cost you more than they pay. Weckr tracks your real LLM cost per user, per feature, and per call, as it happens.

Metadata only. Never your prompts. Fails open. Open source.

Try the dashboard Read the docs

All nine pages live in the demo. No signup required.

Wraps the client you already call

OpenAI
Anthropic
Gemini
Kimi
BOOK A DEMO

Prefer a walkthrough over exploring solo?

Grab 30 minutes with me and I’ll wire Weckr into your actual app live, show you exactly how it fits your product, and answer anything about cost, margin, spending caps, or safety. No slides, just your code.

Book a demo
Safe by default

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 SERVER
app code + Weckr SDK
prompts stay here, enforced in code
unchangeddirect call
LLM PROVIDER
OpenAI · Anthropic · Gemini · Kimi
exactly as before, zero added latency
WECKRasync, fire-and-forget · metadata only: tokens, cost, latency, userId

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.

Read the SDK source at github.com/Ghiles3232/weckr-sdks or see exactly what gets sent in the docs.

The problem

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 like an engaged power user. They are actually your most expensive liability. You will not know until Stripe settles and the OpenAI bill arrives on the same day.

Zero added latency

Logs fire after your LLM call returns. Failures don't bubble to your code.

Per-user margin

See exactly which users cost more than they pay. Plan revenue minus AI cost.

Any provider

OpenAI, Anthropic, Gemini, Kimi. One SDK, one dashboard, one set of units.

What makes Weckr different

Most observability tools sit between you and your LLM provider. We sit beside your code.

Where we sit
Most LLM tools proxy your calls. You swap your base URL or rotate keys.
Weckr is an SDK that wraps your existing client. No DNS change, no SLA on your critical path.
What we measure
Most tools group cost by request or session. Useful for traces, useless for margin.
Weckr groups by (user, plan). You see exactly which customer costs more than they pay.
What we do
Most tools observe and report. They tell you the bill once it's already run up.
Weckr enforces. Caps block or downgrade the call before the model bills you for it.
What we keep
Most tools capture full prompts and responses to power traces and replays.
Weckr captures only metadata: tokens, model, latency, cost. No prompt body ever leaves your server.

Cost per user, the moment it happens

Watch the dollars per user and per feature climb while it is happening, not four weeks later on an invoice. When one customer starts running hot, you see it that same day.

  • Live spend by user, model, and feature
  • Instant cost-per-request from token counts
  • Sortable user table with the worst-margin user always on top
app.useweckr.com/dashboard/overviewOverviewCost, revenue, and margin across all SDK calls in Acme.⚠ 3 users are costing you more than they pay. Combined loss: -$42.30/month.View users →TOTAL COST$142.50TOTAL REVENUE$2,900NET MARGIN$2,757.50UNPROFITABLEACTION3LAST 30 DAYSCostRevenue$120$80$40$0

One line, zero infra

Wrap your existing OpenAI, Anthropic, Gemini, or Kimi client and you're done. The log POST is fire-and-forget after your call returns. No queue, no broker, no SLA on your critical path.

  • Framework-agnostic SDK
  • Edge-compatible (Vercel, Cloudflare Workers)
  • Cost & margin recalculated server-side, so clients can't lie
INSIDE wk.chat( )YOUR APPopenai.chat.create(...your prompt)@WECKR/SDK · wk.chatdetect provider · run call(returns immediately)result returned · 0 ms addedINGEST APIPOST /api/v1/logx-api-key: wk_…POSTGRES (RLS)public.requestscost · margin · planyou log inYOUR DASHBOARDcost · revenue · marginper user · per feature · per planPAYLOAD (FIRE-AND-FORGET){ userId, feature, model, provider, inputTokens, outputTokens, latencyMs, planName, planRevenueUsd, /* cost + margin recalc'd server-side */ }
Real-time alerts

Catch the runaways before they cost you money.

Three background jobs fire automatically the moment a user crosses a threshold, whether that's token velocity, monthly margin, or a Monday-morning summary. All dispatched through your own Slack workspace and email.

Agent loop detection

Sums tokens per user over a rolling window. If a single user crosses your threshold (the default is 50,000 tokens in 5 minutes), we Slack you immediately. Catches runaway CrewAI / LangChain loops before the bill lands.

Margin alerts

Set a negative-margin threshold per project. When a user's monthly margin drops below it (say -$5, meaning “they are losing me more than five dollars”), we ping Slack and email. Cooldown prevents spam.

Weekly digest

Optional Monday 09:00 UTC summary email: last-week cost, revenue, margin, top-3 users, top-3 features, and week-over-week delta. Enable in Settings, paste an address, done.

We never need a Slack OAuth or app install. You paste an incoming webhook URL and we POST to it. Same pattern Sentry and Linear use.
Token velocity·u_42_alice
live
50k / 5min
Velocity anomaly
Slackposted
Emaildelivered
Spending caps

Cap costs before they hit you

Set a monthly spend cap per plan. The SDK checks it before every LLM call. When a user hits their cap, you choose what happens. Silently downgrade to a cheaper model, or throw WeckrCapError so you can show your own upgrade prompt.

  • Per-user, per-plan monthly caps
  • Block the call, or swap to a cheaper model in the same provider
  • 60-second per-user cache, so at most one extra request per minute
  • Fails open: if our service is down, your LLM call still goes through
import { isWeckrCapError } from '@weckr/sdk';

try {
  await wk.chat(openai, opts);
} catch (err) {
  if (isWeckrCapError(err)) return upgradePrompt();
  throw err;
}
app.useweckr.com/dashboard/settingsSettingsSpending caps for Acme. The SDK checks these before every LLM call.PLANMONTHLY CAP (USD)WHEN CAP IS HITfree$2.00Block call▾starter$5.00Downgrade model▾pro$20.00Downgrade model▾business$100.00Block call▾Save capsSaved ✓SDK BEHAVIOURblock → throws WeckrCapError · downgrade → swaps to cheaper model

Get started in 60 seconds

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

Seven days of Pro, free. Cancel from the dashboard whenever you like.

Beta launch pricing: $49/month. Locked in for early adopters.

Hobby

$0/mo

Up to 50k requests/month

For founders shipping their first AI feature.

  • 7-day log retention
  • Basic cost analytics
Get started for free

Pro

Most popular
$49/mo
7 days free, then $49/month. Cancel anytime.

Up to 1M requests/month

For when a few heavy users start moving your margin.

  • Everything in Hobby
  • Unlimited log retention
  • Per-user margin tracking
  • Custom alerts & webhooks
Start 7-day free trial

No card up front. No usage meter running. Leave whenever you like.

The founder

Ghiles Asmani

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.

LinkedIn →GitHub →
Questions

Common questions

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.