Four sections, in the order most people need them.
Install the Nextcloud app
The app is the Nextcloud half of the system: the meeting list, the settings, the chat commands and the files. It does not record anything itself — that is the connector's job, and the two find each other through one key.
Before you start
Nextcloud 30 or newer, with Talk installed.
A High Performance Backend for Talk. Not optional: per-speaker audio is what makes a transcript say who spoke, and without an HPB there is no per-speaker audio to take.
An account on this service — the key comes from there.
Shell access to run occ, or an administrator who has it.
1. Install the app
Unpack the release into your Nextcloud apps/ directory and enable it:
A Meetings entry appears in the top bar. It is empty until the first call is transcribed.
2. Give it a key
In Administration settings → Voxonta, paste the service key from your account. The app checks it immediately and says so if the service does not answer.
The same key goes into the connector in step 3. One key covers both directions: the connector asks the app which calls are live, and the app asks the service what a finished call produced.
3. Connect the capture service
The connector runs outside Nextcloud, on the same machine as your Talk High Performance Backend. It needs three things:
NEXTCLOUD_URL
Where your Nextcloud lives, e.g. https://cloud.example.com
APP_SERVICE_TOKEN
The same key you pasted in step 2
GATEWAY_TOKEN
Your service key, from your account
Running it yourself is described in a section of its own. If we host the connector for you, this step is already done.
4. Hold a test call
Start a call in any conversation, say a few sentences, and hang up. Within a minute or two you should see the transcript in Meetings. The summary and the analysis arrive later — usually within the hour, sometimes longer for a long meeting.
If nothing appears, in this order:
The connector's log — does it say Call monitor started, and does it see the call?
Administration settings → Voxonta — does the service report itself as seen recently?
Whether anybody actually spoke. A silent call produces an empty transcript, and that is a correct answer rather than a failure.
Chat commands
/no-record
Stop transcribing this call
/record
Resume
The commands have to be enabled in the conversation by an administrator, and that is separate from anyone joining the room. In practice they work in the group and public conversations where they were enabled, and not in one-to-one calls, where they normally are not. Sent up to five minutes before a call, /no-record prevents transcription from starting at all.
Where the files land
Transcripts and analyses are written by a service account into its own folders, then shared with the people who were in the call. In a group conversation the app also posts the links into the chat; in a one-to-one it cannot, so the share is the notification.
How it works
Three parts. A connector on your side that hears the call, an engine on ours that turns speech into text, and your own storage where the result ends up.
During the call
The connector joins your meeting the way another participant's browser would, except it neither speaks nor appears in the room. For Nextcloud Talk it connects to your High Performance Backend as an internal client and receives one audio stream per person. That is the whole reason a transcript can say who said what: the voices never get mixed into one track.
Audio streams to the engine while the call runs. Nobody presses record, and there is no recording afterwards — see Your data.
When the call ends
The engine finishes recognising whatever is still buffered and produces the transcript, split by speaker, with timestamps.
The gateway stores it and hands it to the analyser, which writes the summary, the decisions, the open questions and the tasks. This takes minutes to a couple of hours, depending on how long the meeting was.
The app on your Nextcloud asks the gateway what exists, takes it, writes the files into your storage and shares them with the people who were in the call.
What crosses the boundary
Your side → ours
Call audio while the meeting runs; the names of the people in the call, so the transcript can attribute lines; the conversation's name and identifier.
Ours → your side
The transcript, the summary and the analysis files; per-call speaking statistics.
Never
Your files, your chats outside the call, your user list, or anything about conversations that were not transcribed.
Speaker attribution
Each participant's audio arrives on its own stream, already labelled by the meeting platform, so attribution is a matter of record rather than guesswork. Where a platform gives less — a shared track, a guest without a name — the line is marked as an unidentified participant instead of being attributed to somebody plausible.
The parts, named
Connector
Runs on your side. Hears the call, sends audio, asks the app which calls are live. Open source.
Nextcloud app
Runs on your Nextcloud. Settings, meeting list, chat commands; collects finished meetings and files them. Open source.
Engine
Ours. Speech to text, one buffer per speaker.
Gateway
Ours. Holds the results until your side collects them, keeps tenants apart, meters usage.
The short version: the results are yours and live in your storage. Our copies are working copies, and they expire on a timer we can show you.
How long we keep things
Call audio
Not kept. It is recognised as it arrives and never written down as a recording.
Transcript, summary, analysis — our copy
7 days from the end of the call, then deleted. Long enough for your side to collect them even if it was offline for a few days.
The analyser's working copy
30 days, then deleted with everything it produced.
Speaker profiles
Kept while at least one of that person's meetings is still stored. When the last one expires, the profile goes with it.
In your Nextcloud
As long as you keep it. Those files are yours; we neither delete them nor can we.
About the audio
Recognition is not instant, so speech is held in memory in short pieces while it is being processed. Under memory pressure a piece can briefly go to disk, and it is deleted as soon as it has been recognised — including any leftovers, on restart. What never happens is a recording being saved: there is no file of your meeting anywhere on our side, and no way for us to produce one after the fact.
Who can see what
Between customers — every meeting belongs to one workspace, and a request carrying one workspace's key can only ever reach that workspace's meetings.
Inside your Nextcloud — files are shared with the people who were in the call, and Nextcloud's own permissions decide the rest. We do not know who your users are; only your Nextcloud does.
Speaker portraits — a person's own analysis file is shared with the people who were in that meeting, like the rest of it.
Deleting things earlier
A meeting can be dropped from our side before its seven days are up — the copy in your Nextcloud is unaffected, because deleting there is your business, not ours. Write to hello@voxonta.com with the workspace and what you want gone; there is no self-service button for it yet, and pretending otherwise would be worse than saying so.
What we do not do
Train models on your meetings.
Read your transcripts, except when you ask us to look at something specific.
Sell or share anything with anyone. There are no advertising integrations and no analytics inside the product.
Where it runs
Speech recognition runs on our own servers, on a model we host ourselves. Your audio does not go to a third-party speech API.
The analysis step uses a language model, reached through OpenRouter. The text of the meeting — never the audio — is sent to be summarised. Two things constrain who can see it:
Only providers whose policy is not to retain or train on request data are eligible; the rest are excluded at the request level, not by trusting a setting somewhere.
Providers we have specifically ruled out — for quality or uptime — never receive anything either.
Which of the remaining providers serves a given request is decided per request, so we cannot promise you one name in advance. What we can promise is the rule they all satisfy. If your security people need the current list rather than the rule, ask and we will send it — it changes as providers come and go.
Run the connector yourself
The piece that hears your calls is the piece most worth keeping on your own hardware. It is open source, it runs beside your Talk High Performance Backend, and it only ever makes outbound connections.
What it is
A small Python service. It asks the Nextcloud app which calls are live, joins them through your High Performance Backend as an internal client, and streams each participant's audio to the engine. It does not join as a visible participant, does not speak, and does not appear in the room.
The same machine as your Talk High Performance Backend. Audio takes the shortest path that way, and no extra port has to be opened anywhere.
Docker
It ships as an image; nothing is installed into the host Python.
Outbound access
To your Nextcloud, and to our gateway on 443. Nothing inbound: no port to forward, no rule to add.
Resources
Modest — it moves audio rather than recognising it. Recognition happens on our side.
Settings
NEXTCLOUD_URL
Your Nextcloud, e.g. https://cloud.example.com
APP_SERVICE_TOKEN
The key from the app's admin settings
GATEWAY_TARGET
gw.voxonta.com:443
GATEWAY_TOKEN
Your workspace key, from your account
NC_APP_ID
Optional. The app's id, voxonta by default — only needed if you renamed it
Everything else — which conversations to transcribe, how the connector signs in to Nextcloud, how long to keep results — comes from the app's admin settings, so it is configured in one place rather than two.
Checking it works
On start it should say, in this order, that it loaded settings from your Nextcloud, that it is streaming to the gateway, and that the call monitor started. If instead it repeats could not read live calls, the app is not answering — wrong URL, wrong key, or the app is not enabled.
What stays ours
Speech recognition, the gateway that holds results, and the analyser are not open source and run on our infrastructure. We are not going to pretend otherwise: what you can self-host today is the capture path and the Nextcloud side, which is the part that touches your calls and your users. Recognition needs hardware and a model we maintain; running it yourself is a conversation to have with us rather than a download.
Not here yet
Sources other than Nextcloud Talk, and the API for reading meetings from your own tools. Both exist in some form; neither is documented well enough to publish, and a page that describes something almost accurately is worse than no page.