Credyt is usage-based billing infrastructure for vibe coders.
Ship credit packs, hybrid plans, and a real-time billing portal in one prompt. Wallet balance, top-ups, plan management. No billing backend to build.
https://t.co/fsDuNDlQuV
The AI product on four model providers cannot tell you what each provider cost last week.
The bill arrives monthly. Routing decisions happen daily. A model swap decided on last month's bill is a swap decided on a stale graph.
Vendor cost has to be a query, not a quarterly export.
Total spend per vendor, broken down by category, is now a single query. Period filters included.
Most AI products run on more than one model provider. The monthly bill shows the total; it does not show what each provider cost per workload.
Costs attach to vendors at the event level. The read is the aggregation.
Credyt's TypeScript SDK is available with full type coverage for every endpoint.
Strongly typed methods for wallet operations, authorization, usage capture, grants, and the billing portal. Node and Deno both supported.
Install via npm or yarn, configure the API key, and the SDK handles signing, retries, and typed errors. Reference examples live in the docs.
An audit trail that doesn't record tokens can't answer questions about token cost.
If cost per request varies by model, prompt length, completion length, and retry count, the billed amount is a summary that discards the variables.
What you didn't record, you can't explain.
Every usage event is recorded with model, prompt tokens, completion tokens, cost, and timestamp.
Most billing tools store the billed amount and a category. When a customer asks why a month cost more, you cross-reference billing logs with model logs with finance sheets. (Half a day every time.)
Token-level audit trails record the variables that drove the cost. One query answers support, finance, and engineering at the same time.
What you didn't record, you can't explain.
Native Stripe support in Credyt for wallet top-ups and subscription billing.
Connect a Stripe account; customer payments flow through Stripe directly to the connected account. No custom payments flow, no markup on top of Stripe's standard fees.
Top-ups run on Stripe Checkout inside the branded billing portal. Subscription charges hit the same connected account. The Adjustments API covers external payment flows.
Pricing models are not interchangeable, but billing systems usually act as if they are.
Enterprise sells on seats. Self-serve sells on usage. Hybrid sells on both. A platform that forces one shape pushes the compromise into the contract.
The right primitives let the deal shape the bill, not the other way around.
Seat-based pricing is now a billing-model option alongside usage. Charge per active user, per unit of usage, or both on the same customer.
The shape matters when enterprise buyers price on seats first and usage second. A 200-seat rollout cares about per-seat economics even when workload is variable.
Seats and usage live on the same subscription primitive.
Margin reported monthly is margin you can't act on.
If a customer's per-request cost depends on model, retries, and feature mix, learning their margin at cycle close is running a postmortem.
Margin is decided at the point of authorization, not at the end of the month.
Per-customer margin is now a real-time number, not a month-end report.
Most billing tools report revenue and leave cost in a warehouse. Joining them is a monthly job that ships a week after close. (By then the unprofitable customer has spent four more days at negative margin.)
Credyt correlates revenue and cost at the event level. The fee lands as revenue, the vendor cost lands against the same event, margin rolls up per customer. The dashboard moves the same day.
Per-customer unit economics, legible while they're still actionable.
Invoice billing was designed for a world where cost was known in advance. AI is not that world.
If your per-customer cost depends on model, retries, and feature mix, a billing system that discovers cost at month-end is discovering it too late.
You cannot bill for what you cannot measure in real time.
Usage events are priced and debited against the customer's balance the moment they arrive. No reconciliation job, no nightly batch.
Invoice billing assumes metering and billing can split into stages with time between them to reconcile. (For an AI product where the model bill arrives daily, that gap is where the margin surprises live.)
Credyt collapses the stages. A single POST submits the event. Credyt prices it, generates the fee, and debits the wallet atomically. The balance is current before the next request.
Cost is realized at the moment of action. Billing should be too.
Credyt's Python SDK is available with full coverage of every API endpoint.
Typed methods for wallet operations, authorization, usage capture, grants, and the billing portal. Fits backend services, data pipelines, and inference workers.
Install with pip, configure the API key, and the SDK handles signing and retries. Python examples are in the docs alongside TypeScript.
Gen Z will let AI dig through every listing and comp, then still want a human in the room to actually sign. Trust in AI ends right where the money gets real. https://t.co/HDM6zxw41J
$20k to $5k through smarter routing and model tiers. That's the AI cost story no one's writing about. Credyt shows you where every token dollar goes before you start cutting.
I'm starting to hit $15-20k per month in token spend for engineering - just for myself.
Next month I'll be looking to implement the kinds of things that Brian is doing here at Coinbase.
Most likely switching to GLM 5.2 as default and only using frontier models for harder tasks.
I can probably get that $20k down to <$5k pretty easily.
I'm pretty sure we'll see everyone doing this.
It's just not financially viable to do everything with frontier models
This is another reason I think we'll see people move away from choosing a lab for their harness (CC or Codex) and move their code factories to in-house agents like @tryramp or agent labs like @DevinAI@FactoryAI@cursor_ai@AmpCode
The labs are not incentivized to drive down your token costs
Per-token is the metric you can measure. Per-outcome is the metric customers care about.
Most AI products bill on tokens because that's what the model API meters. The customer experiences a finished report and is asked to translate it into tokens. They didn't sign up to do that math.
Margin lives in the gap between the measured unit and the billed unit.
The billable event can be the outcome the customer experienced, not the tokens the model consumed.
Most AI billing meters what the API meters: tokens, calls, compute seconds. So the pricing page quotes a per-outcome price and engineering back-solves to a token budget. (The budget shifts the next time you swap models.)
Outcome-based pricing meters the outcome directly. Token cost still flows through cost attribution, so margin per outcome stays visible. The customer sees the price they signed up for.
The billed unit should match the unit customers care about.
The OpenAPI spec for Credyt is published, and webhook callbacks are supported.
The spec is machine-readable and covers every endpoint. Generate clients, drive contract tests, or feed it into an AI coding tool to scaffold the integration.
Webhooks fire on billing, balance, and alert events. Configure endpoints, pick event types, and Credyt sends the payload as events happen, with retries and signature verification.
A welcome credit modelled as a recurring entitlement set to "never refresh again" is a workaround, not a design.
Bundled entitlements refresh because plans refresh. Signup credits and trial top-ups don't. Forcing them through the same shape leaks complexity into reporting and pricing changes.
Same wallet, same draw-down rules, different lifecycle.