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.

drop-in

Works with the providers you already use

OpenAI
Anthropic
Gemini
Built for trust

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
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 most active users are often your least profitable ones.

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.

Provider-agnostic

OpenAI, Anthropic, Gemini. 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.

Watch costs as they happen

See dollars-per-user and dollars-per-feature update in real time. Catch a runaway customer before your AI bill arrives. No end-of-month surprises.

  • 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, or Gemini 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.

Simple, transparent pricing

Start with a 7-day free trial. Cancel anytime from inside the dashboard.

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 scaling applications that need deep insights.

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

No credit card required. No usage based surprises. Cancel anytime.

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.

LinkedIn →GitHub →
Questions

Common questions

Those dashboards show you a single total for your whole account. Weckr shows cost and margin broken down by individual user, so you know exactly who is profitable and who is not, not just how much you spent overall.

No. The SDK logs cost metadata only, token counts, model, latency, and the userId and feature you pass in. Prompt and response text are never sent, never stored, never seen.

No added latency. Weckr logs asynchronously in the background using fire and forget delivery, your LLM calls go directly to the provider exactly as before.

OpenAI, Anthropic, and Gemini today, with LangChain and CrewAI integration docs available. More providers are on the roadmap.

Nothing happens to your app. Weckr sits outside the request path, so your LLM calls never depend on us being available. Logging simply pauses and resumes.

Free up to 50000 requests per month. Pro is 49 dollars per month with unlimited requests, spending caps, loop detection, and model recommendations. No usage based pricing.

It depends entirely on which model you use. With a cheap model like gpt-4o-mini, 50,000 requests might cost you around $13. With a frontier model like GPT-5 or Claude Opus, the same 50,000 requests can cost $300 or more. This is exactly why total spend alone tells you so little, and why per user, per model visibility matters more than a single number.

Yes. Set a cap in the dashboard with no code required, choose whether to block the call or automatically downgrade to a cheaper model when a user hits their limit.

If a single user session exceeds 50000 tokens in 5 minutes, Weckr fires a Slack alert immediately. This catches a runaway AI agent before it burns through your budget, often before you would otherwise notice.

Yes. The full SDK source is MIT licensed on GitHub. You can read every line that runs in your app and remove it in about 10 minutes if you ever want to.