A transcription tells voices apart but cannot know which one is the agent. Save each agent once, from one of their own calls, and every call after that comes back with the agent named, a summary on top and a spreadsheet ready for QA.
A QA lead who reviews support calls by listening can get through a handful a day, and a seven-minute call takes seven minutes however fast you click. Read as text, the same call is about a thousand words, one page, and a page can be skimmed, searched and pasted into a ticket. Customer service call transcription turns the recordings your phone system already keeps into those pages. Three things decide whether the pages are any use: whether each line says who spoke, agent or customer; whether the call comes with a short summary of what was asked and what was agreed; and whether the result lands where the team works, a CRM note or a QA spreadsheet.
This article walks through that workflow with VocalStack: recorded calls sent through the API, the agent recognised by name, a summary written for each call, and exports in JSON and Excel. It also says plainly what VocalStack does not do for a support team, because some of it matters before the first call is uploaded.
Most phone and contact-centre systems can export call recordings as audio files, or give each one a download link. Either works. POST /v1/transcriptions takes a file as a multipart upload, or a JSON body with a url that the server fetches itself. The file tutorial covers the call in detail; for calls, these settings matter, all inside settings:
speakerLabels: set it to on, so every line of a two-person call carries a speaker. The default, When Needed (auto), labels lines only once a second speaker is heard, which suits a lecture better than a call.summary and title: both are off unless you ask. With them on, a title and a short summary are written for the call once it is transcribed.spokenLanguage: name it when you know it, as in a queue that only takes calls in one language. Leave it out and the language is detected, from 100.The upload answers at once with a transcription id; the words come a little later. Send an Idempotency-Key with each upload: a retry with the same key and body within 24 hours returns the first transcription instead of making, and billing, a second. The call's own id from your phone system is a natural key.
import { VocalStack } from '@vocalstack/js-sdk';
const vs = new VocalStack({ baseUrl: '{{api}}', apiKey: process.env.VOCALSTACK_API_KEY });
const tx = await vs.transcriptions.create(
{
file: './calls/48213.mp3',
name: 'Ticket 48213',
settings: { speakerLabels: 'on', summary: true, title: true },
},
{ idempotencyKey: 'call-48213' },
);
const job = await vs.transcriptions.waitForJob(tx.id, { intervalMs: 5000 });
if (job.state !== 'done') throw new Error(`call 48213: ${job.state} ${job.error ?? ''}`);
A night's recordings can go up in one loop. Each plan sets how many transcriptions run at once, and a file over that number is not refused: it is created, waits queued, and starts by itself when an earlier one ends. The limit you can hit is the number of transcriptions an account may start through the API in an hour; the figures for each plan are on the pricing page. There are no webhooks, so your script polls each job until it is done, which waitForJob does for you.
Speaker labels come from diarization: the recording is split into turns, and the turns are grouped by voice. What comes back is "Speaker 1" and "Speaker 2". The system can tell two voices apart, but nothing in the audio says which one is employed by you. Diarization vs speech recognition explains the mechanics; for support calls, the practical answer is to save each agent once.
A saved speaker is a voice fingerprint with a name. Once it exists, every new transcription in the account compares the voices it hears against your saved speakers, and a match carries the name into the transcript. Files are matched automatically, so the agent's lines arrive as "Dana" instead of "Speaker 1". The customer stays numbered until you name them.
Take the fingerprint from one of the agent's own calls rather than from a recording made at a desk. A voice on a headset in a quiet room and the same voice on a phone line can sound less alike to a machine than two different people recorded the same way, and the fingerprint matches best against audio like the audio it came from. POST /v1/speakers/from-appearance saves a speaker straight from a transcription, using that speaker's own stretches of the call as the sample. appearance is the speaker index their lines carry.
await vs.speakers.createFromAppearance({ transcriptionId: tx.id, appearance: 0, name: 'Dana (Billing)' });
Saving a speaker this way keeps only their fingerprint, from at least 5 seconds of their speech; a call where the agent talks for a minute or more gives a steadier one. Voice cloning is a separate step that needs the person's consent, and a support workflow has no use for it.
From then on, a finished call's transcript tells you who was recognised. GET /v1/transcriptions/{id}/transcript lists speakers, and a speaker matched to a saved one has identified: true and the saved name. The rest can be named in one call each, PUT /v1/transcriptions/{id}/appearances/{number}, where number is the speaker's display number. Naming is stored on the transcription, so every export after it reads "Customer" instead of a number.
const { speakers } = await vs.transcriptions.transcript(tx.id);
for (const s of speakers) {
if (!s.identified && s.number != null) await vs.transcriptions.nameAppearance(tx.id, s.number, 'Customer');
}
Treat "everyone not recognised is the customer" as a rule of thumb and check it on your own calls. A transfer brings a second agent, a recorded menu prompt can be heard as a voice of its own, and an agent who has not been saved yet looks exactly like a customer. Also note how the comparison is bounded: each transcription is compared against the 64 saved speakers most recently updated in the account, so a team larger than that should not count on every agent being recognised on every call.
Two properties of phone audio are worth knowing before you judge the labels. A dual-channel recording, with the agent on the left and the customer on the right, is mixed down to one channel when it is transcribed, so speakers are separated by their voices, not by their channel. And a narrowband phone line carries nothing above about 3.4 kHz, which removes part of what makes two voices distinct; short, overlapping turns ("yes", "mm-hm", "sorry, go on") are where labels go wrong most often.
With summary and title on, each call gets a title and a few sentences on what it was about once the transcript is final. That is what goes into the ticket, so the next agent knows the history without opening anything. The summary is written after the transcript, so read it with GET /v1/transcriptions/{id}/summary and wait while its state is pending:
let sum = await vs.transcriptions.summary(tx.id);
while (sum.state === 'pending') {
await new Promise((r) => setTimeout(r, 3000));
sum = await vs.transcriptions.summary(tx.id);
}
When state is ready, title and summary hold the text. A recording shorter than one minute never gets a summary (not_requested), which matters for voicemail: most voicemails are short enough that the transcript is its own summary. A call made without summary can be given one later with POST /v1/transcriptions/{id}/summarize. Summaries are included in every plan at no extra cost.
GET /v1/transcriptions/{id}/export returns a file in one of seven formats: json, xlsx, pdf, srt, vtt, txt or md. Every export includes corrections and the speaker names you gave. For a support team, two of them do most of the work.
JSON for your own code. The JSON export has the call's name, language, durationS and, with summary=true, its summary, then segments: one entry per line, with start and end in seconds, speaker, speakerName, text, a confidence, whether the line was corrected, and the words with their own timings. That is enough for a script to build a CRM note (the title, the summary, the agent's name, the call's length), or to pull every line the customer said.
const res = await vs.transcriptions.export(tx.id, 'json', { summary: true });
const call = await res.json();
const note = { subject: sum.title, body: sum.summary, minutes: Math.round(call.durationS / 60) };
// Your code posts `note` to the ticket: VocalStack has no CRM or helpdesk connector.
Excel for the reviewer. The XLSX export has a Transcript sheet with one row per line and the columns #, Start, End, Start (s), End (s), Speaker, Text, Confidence and Corrected. With summary=true, the About sheet carries the summary beside the call's name, language and length. A QA lead can filter to the agent's rows, add a column for scores or comments, and keep one workbook per review.
curl -sSf "$API/v1/transcriptions/$TX/export?format=xlsx&summary=true" -H "$AUTH" -o ticket-48213.xlsx
Support in more than one language works the same way. Add lang=en to an export and the file reads in English, one line per sentence, translated where the call was in Spanish or Polish; a reviewer who reads one language can score calls taken in several. The PDF export suits the person who wants to read a whole call on paper, with speakers and timestamps.
A transcription stays in the account after it is exported, so the calls build into a library. Tags group them: create one per queue or team with POST /v1/tags, then put it on transcriptions with POST /v1/tags/{id}/transcriptions.
const billing = await vs.tags.create({ name: 'Billing queue' });
await vs.tags.tagTranscriptions(billing.id, { add: [tx.id] });
GET /v1/search then searches what was said across every call, narrowed by tag and date: every billing-queue call this month where someone said "cancel", each hit with its call and the second it was said.
curl -sSfG "$API/v1/search" -H "$AUTH" --data-urlencode "q=cancel" \
--data-urlencode "tag=Billing queue" --data-urlencode "createdAfter=2026-11-01"
Everything above also works without code. A file uploaded at Transcriptions → New is labelled, summarised and exported from its page, speakers are saved under Speakers, and tags and search sit in the Transcriptions list.
Some gaps are worth knowing before anything is set up.
Retention depends on the plan; the pricing page shows how long audio and transcriptions are kept on each. A transcription can be archived, and an archived one purged with POST /v1/transcriptions/{id}/purge, which deletes it and everything in it for good.
At launch prices, recorded calls are $0.20 per hour of audio, billed per second ($0.0033 a minute), with a 5-minute minimum per transcription on Pay as you go (none on Premium or Enterprise). The current rates are on the pricing page. Speaker labels, speaker naming, summaries, translations and exports never add to the bill.
Support calls are often short, so the minimum decides more of a support team's bill than the rate does. On Pay as you go:
On Premium and Enterprise there is no minimum, so every call is billed by its own seconds: the 40-second voicemail costs about a fifth of a cent, and the 1,000 three-minute calls about $10. A team that mostly takes short calls should compare the two on its own call lengths.
At launch prices, a team that records 2,000 calls a month averaging 8 minutes sends 16,000 minutes of audio: about $53 of credit a month on Premium, summaries and spreadsheets included. On Pay as you go, every call under 5 minutes adds to that.
Live transcription costs more ($0.60 an hour at launch prices), because it keeps pace with the call; if nobody needs the words during the call, transcribe the recording afterwards. A new account starts with one-time signup credit and no card is required, so the steps above can be tried on a batch of your own calls before anything is bought.