Build the portal to launch your AI product.
A gateway your customers call, model names you own, routing you control, metered and capped while the response is still streaming.
Monetization
Plans, balances, and your markup. See provider cost and revenue on the same ledger.
Access
Choose which models each customer can call, under your own names. Repoint without redeploying.
Control
Know who is calling and what they can spend. Caps are checked while the stream is open.
What your customers buy
The portal is the product. The gateway is how it holds.
Your customers get one page that answers what did I spend and how much is left, under your name, on your subdomain. Every answer it gives is a support ticket nobody has to read.
- Four pages your customers read, not four you build
- Usage, spending, keys and activity, hosted at <app>.portal.ourseams.com with your product name, your colour and your logo. Your customers never see ours.
- The gateway underneath is what makes the page true
- Every number on it was written on the request path: metered as the response streamed, held against a balance, settled to the cent. Nothing is reconciled overnight.
- The names and the limits are yours to set
- Bundles decide which models a caller can reach. Routers decide how those names resolve. Caps decide when a call stops, including mid-stream.
Why not build it
A proxy and a meter is a weekend. Money that is right mid-sentence is not.
What runs on every request, in order.
Forwarding the request is the easy half. The hard half is a ceiling that holds while the answer is still arriving: money held before the request leaves, re-checked against tokens that have not finished streaming, released to the cent when it ends. Check the cap only before the call and you either bill for tokens you never served or serve tokens nobody paid for.
- 01
reserve
hold the money on the balance before the request leaves, in one atomic step
- 02
stream
re-check accumulated spend every 16 chunks, and every 250ms
- 03
abort
at 98% of the hold: stop the model provider connection, send a usage block, send [DONE]
- 04
settle
release the hold, write one ledger row, reconcile to the cent
Where the line is
You still build a product. We build the layer under it.
Nothing here is a surprise on the day you integrate.
You still own
- Stripe: invoices, tax, dunning, chargebacks
- Your product, your sign-in, your customers
- Which model to call, and when
- What you charge, and collecting it
We ship
- Stripe: invoices, tax, dunning, chargebacks
- Your product, your sign-in, your customers
- Which model to call, and when
- What you charge, and collecting it
- Invoicing, revenue recognition, dunning and tax. Stripe does those; we do not wrap them.
- Merchant of record. Your customers pay you, and the legal relationship stays yours.
- Embeddings, images and audio. The gateway meters text and agent traffic.
- Your prompts and completions. There is no column for a message body and no code path that writes one.
Build with seams
Everything between the model and the invoice
From the first call to your thousandth customer: who may reach which model, how that name resolves, and how spend is metered and capped.
Access under names you own
Bundles decide which models each customer can reach. Aliases and routers decide how those names resolve. Change them without redeploying a client.
Keys your team mints and revokes
One key per end user on a shared balance. Mint and rotate credentials without splitting spend. Revoked keys stay listed for audit.
A portal with your name on it
Hosted at <app>.portal.ourseams.com, in your brand. Usage, spending, and keys. Your customers never see a vendor name.
Margin you can see before the invoice
See which models drive cost and margin so you know what to price and what to keep.
Budget a job, not a request.
One support reply, one document summarised, one agent run, however many calls that takes. A key cap limits a period; an outcome limits a unit of work, and the ceiling holds across every call in the run.
Read about outcomesHow this compares
They own a box. The edges are still hand-written.
Three categories, and they do not overlap. Routers pick a model. Dashboards report what it cost. Neither one knows who your customer is or what they are allowed to spend.
A routing proxy
OpenRouter, LiteLLM, Portkey
One model name across many providers, with fallbacks.
You still write
Who may call it, what they may spend, and who pays for it.
An observability tool
Helicone, Portkey
What every call cost, once it has finished.
You still write
A ceiling that stops the call, and a page your customer can read.
Seams
Catalogue, entitlement, spend and a branded portal on one request path, checked together.
You still write
Which model to call. That judgement is your product, and we do not make it.
Frequently asked questions
Common questions
Forwarding a request and counting tokens afterwards is a weekend. The part that is not is a ceiling that holds while the answer is still arriving: money held before the request leaves, re-checked as the stream runs, released to the cent when it ends. Check the cap only before the call and you either bill for tokens you never served or serve tokens nobody paid for.
All the portal infrastructure your product needs
Gateway, aliases, and routing behind names your product owns.
Metering, holds, and spend caps that hold for the life of the stream.
A portal on <app>.portal.ourseams.com, keys, usage, and limits under your name.
Point your clients at Seams
sign in, connect a provider, ship
Sign in, point your base URL at your application gateway, and mint a key for your first customer. Metering and caps start on the first call. Bring your own provider key to start.