Kammarkoll
Search what has been said in the Swedish Riksdag. Press the microphone and ask aloud: the question is transcribed as it is spoken and becomes the search.
Live, from the visitor's browser to a nodeSpeech to text for your product.
Stream a microphone live over WebSocket or WebTransport, or send a recorded file and get it back split by speaker. Your users never need an account with us: your server signs a short token and we check it.
Try it: press and speak
No account needed.
Ready when you are
Press the button to speak
0.0 / 60s
Your browser will ask for the microphone. Nothing is stored.
Your recordings
Sixty seconds of audio every ninety seconds per visitor, so speaking without a pause means a thirty-second wait between takes. The limit holds three times over: this page asks a gateway for a grant, the grant carries the sixty-second budget inside its signature, and the demo account has a finite balance. Getting past the first still leaves the other two.
- First hour free
- From €2 an hour + VAT
- Paid per second, no monthly fee
- Processed in the EU
Already running on it
Two sites of our own use Transcribe Today every day.
Renskrivet
Upload a recorded interview, meeting or podcast and read it as text, split by who is speaking, with a time at every turn. See a finished text.
Files, with speakers told apartPrices
Pay for the seconds of audio you send, nothing by the month.
- Recorded files, speakers told apart €2 an hour + VAT €2.50 including 25 % VAT
- Live, over WebSocket or WebTransport €3 an hour + VAT €3.75 including VAT
- To try it 1 hour free To test it on your own audio
- More credit, by card in the dashboard €10 + VAT and up €10 (€12.50) for 5 h, €50 (€62.50) for 25 h, €200 (€250) for 100 h
In euro. Swedish VAT, 25 %, is added at checkout. For businesses and consumers, on our terms.
Billed per second actually spoken, never rounded up to the minute. You pay in advance: buy credit by card in your dashboard whenever you like, and it is there at once and does not expire. A live second takes one and a half seconds of credit, which is the difference between the two prices. As a consumer you can withdraw from a purchase within 14 days and get back what you have not used. Over a hundred hours a month, invoicing, or a data processing agreement: write and we will quote.
Audio is processed in the EU, on servers of a European company, and never passes through an American one. If yours must stay in Sweden, say so.
We help you all the way until it works in your product: write, and a person answers, no ticket queue.
hello@pikoman.seHow to begin
Ask for an API key
Write to us and we open your account, with the first hour free. You get a dashboard, an API key and an ed25519 key pair, or you register a public key you made yourself and we never hold the private half at all. More credit is bought by card in the dashboard. Signing up, you accept the terms.
Sign grants on your server
Sign your users in however you already do, then sign a short token saying who may speak and for how long.
Send your users to us
They connect with that token. We check the signature, apply the limits and count the seconds.
The worked example is about ninety lines of Node, with no dependencies.
How it works
Your server vouches for your users with a signature. We check it, count the seconds and charge your account.
One part keeps the accounts, one listens
The service is split in two, and the split is the whole design. The control plane knows who the customers are, what they have paid for and how much they have left. The data plane only turns audio into text as fast as the hardware allows.
The control plane holds customers, signing keys, plans, credit and usage history; its traffic is low and it wants durability more than speed. The transcription nodes hold none of that. They scale sideways, and when they need to know whether a speaker may go on, they ask.
So your own users never hold an account here. You vouch for them, and the vouching is cryptographic, not a matter of trust.
You sign, we can only check
Each customer holds an ed25519 private key; we hold only the public half. When one of your users wants to speak, your server signs a short-lived token saying who the user is and how many seconds they may use.
The limits are inside the signature, so they cannot be changed on the
way. A user who opens the console and changes max_audio_seconds
from sixty to sixty thousand gets a token that no longer verifies.
A shared password would let us make tokens in your name. A public key only lets us check them.
From a click to a word
The user signs in with you. You sign a grant. The user takes it to a transcription node, which checks it with the control plane. Audio flows, and seconds are counted and charged as they are spoken, not only at the end.
If the control plane goes quiet, the node checks signatures itself against keys it cached earlier and keeps listening, writing down what is owed for when it is back.
A refusal is obeyed
If the control plane says a customer is out of credit, the node refuses. It never guesses in the customer's favour.
Silence is not a refusal
A timeout means no answer was given, so the node decides for itself and settles up later.
Try the rules yourself
Three small tools that run in this page and show how the real service behaves.
The seven checks a token goes through
Every token runs the same seven checks in the same order and stops at the first failure. The messages are the ones the service really returns. Spoil the token, then send it.
Read a grant token
Paste any token. It is decoded in this page and sent nowhere.
Decoding is not verifying. A token's claims are plain text to whoever
holds it, so reading them proves nothing; only checking the signature
does. That check needs the public key, which is why we publish
it openly at /v1/customers/{slug}/jwks.json: it can confirm
a signature, never fake one. Only the private half must never leave you.
Header
Claims
How your credit is counted
Credit is not a number we overwrite. It is a list of entries, and the balance is what they add up to. If you question an invoice, every second can be traced to the rows that produced it.
| Entered | Reason | Reference | Seconds |
|---|
Balance
0
seconds
SUM(delta_seconds)
The API
Every address your servers call, and a place to call them for real from this page.
Endpoints
What each one is for, and who calls it.
Try the API with your key
Paste an API key and this calls the service for real. Requests go straight from your browser to the address below and nowhere else; no server behind this page holds your key.
Paste a key and press "Read my account".We never ask for your real private key. "Generate a test key" makes a throwaway pair inside your browser, registers only the public half, and signs with the private half without it ever leaving this tab, which is exactly the shape of the real integration.
Code to start from
Clone a working demo, or copy the whole integration in the language you already use.
Clone a working demo
Two complete integrations, each a few hundred lines with a microphone and a live transcript. They differ in one choice: whether the audio passes through your servers.
Start here
Straight to the node
Your server mints a grant; the browser streams directly to us. Audio never touches your infrastructure, so it costs you nothing per spoken second and adds no latency.
git clone https://transcribe.today/demos/demo-browser.git
cd demo-browser
cp .env.example .env # your SLUG, KID, PRIVATE_KEY
npm start # no dependenciesdemo-browser.zip No dependencies
Through your own server
The browser talks only to you. Your server holds the grant, relays the audio and logs every transcript. Choose it when you need custody: records to keep, redaction, an audit trail.
Smaller still: customer-server
is ninety lines that mint tokens and nothing else:
git clone https://transcribe.today/demos/customer-server.git
Your private key lives in .env, which is gitignored in every
one of them. It signs grants on your server and must never reach a browser.
The whole integration
In the language you already use.
Live sessions
What happens when a speaker runs out of seconds, and when part of our service goes quiet.
Top up without cutting the speaker off
A grant carries a budget of seconds. When it runs out the session ends, which for someone dictating a letter comes at the worst moment. So a live session can be extended without reconnecting.
Send a fresh grant over the open connection. Its seconds are added to what the session already had, so you can hand out a minute at a time without tracking how much has been used.
The grant must name the same customer and the same end user. One of your users cannot extend another's session, and nobody else's grant can move a session onto your account.
Nothing is dropped: no reconnection, no gap in the audio, no missing words in the transcript.
If the control plane goes quiet
A refusal from the control plane is a decision and is always obeyed. A timeout is not: it means no decision was reached. The node then checks the signature itself against cached public keys and keeps transcribing.
Two things still hold offline: signatures are checked, and a token can still be used only once on that node. What cannot hold is credit, since the ledger is elsewhere. The seconds used are queued and settled when the control plane answers again.
The trade is deliberate and it favours you: your users keep speaking through an interruption on our side, and the account is squared up afterwards instead of sessions being dropped.
Limits to design around
- Token lifetime 3600 s ceiling
- Mint whatever lifetime you like; we decline to honour anything longer than an hour. Minutes are the sensible choice.
- Single use
- A token is spent on first use. Mint one per connection: a reconnect needs a fresh one, and so does each top-up.
- Extending a live session
- Send a fresh grant over the open connection and its seconds are added to the session. Same customer, same user, no reconnect.
- Clock skew 60 s
- Allowed either side of exp and nbf, so your signing server need not be perfectly in step with ours.
- Algorithm EdDSA only
- ed25519 signatures. An alg of none, or an HMAC substitution, is refused before anything else is read.
- jti required
- Without one a token cannot be single-use, and will be refused.
- Effective limit
- The least of what you granted, what your plan allows, and the credit left on your account.
- Key rotation
- Several signing keys may be active at once, so you can roll out a new one before retiring the old. We refuse to retire your last one.
Your first hour is on us.
Write to us and we open your account. Stuck later? Write again, and a person answers.