Short answer. Normalize the transcript to timed segments, map diarization labels to real people with confirmation, extract actions and decisions with evidence timestamps, and sync to the CRM with idempotency keys and a human approval step.
Normalize the transcript
Transcript quality decides the quality of everything downstream. A blob with no timestamps cannot support “who agreed to what.” Normalize to segments before the model sees anything.
| Field | Type | Notes |
|---|---|---|
meeting_id | string | Stable ID from the calendar or recorder |
segment_id | string | Unique within the meeting |
start_ms, end_ms | integer | Milliseconds from the start |
speaker_label | string | Diarization label such as SPK_2 |
text | string | Verbatim or cleaned, not summarized |
language | string | BCP 47 tag |
confidence | number | Provider confidence, if available |
If you use an audio endpoint such as /v1/audio/transcriptions, keep the provider's word timings and speaker labels, then normalize them. Keep the raw response; it is the evidence when a summary is disputed. Clean filler words only if you also keep the original, because “I don't think we should” and “we should” are different decisions.
Map speakers to people
Diarization tells you that speaker 2 talked for 40 seconds. It does not tell you that speaker 2 is the customer's VP of Operations. Map labels to identities from the calendar, attendee list and introductions, then ask a human to confirm. A wrong attribution can turn an internal suggestion into a customer commitment.
- Use the roster: accepted invitations and the recorder's participant list are better evidence than a voice embedding.
- Confirm, don't guess: if two attendees have similar names or one dialed in, flag the segment.
- Handle unknown speakers: keep
unknown_1and let the user label it later. Store the mapping separately so it can be corrected. - Consent and notice: recording laws vary by jurisdiction and by whether all parties are present. Follow your policy and the law; this page is not legal advice.
Extract actions and decisions
An action needs an owner, a verb, a due date and a source. “We should improve onboarding” is not an action. “The account lead to send the revised checklist by 24 November” is. A decision needs rationale, deciders and date. Keep open questions in a third bucket so they do not become fake actions.
import json
from openai import OpenAI
client = OpenAI(api_key="YOUR_KEY", base_url="https://api.plugsky.com/v1")
segments = [json.loads(line) for line in open("meeting.jsonl", encoding="utf-8")]
numbered = "\n".join(
f"[{s['segment_id']} {s['start_ms']}-{s['end_ms']}] {s['speaker']}: {s['text']}"
for s in segments
)
schema = {"actions": [{"title": "string", "owner": "string or null",
"due_date": "YYYY-MM-DD or null", "status": "proposed|confirmed",
"evidence": ["segment_id"]}],
"decisions": [{"decision": "string", "rationale": "string or null",
"deciders": ["string"], "evidence": ["segment_id"]}],
"open_questions": [{"question": "string", "evidence": ["segment_id"]}]}
response = client.chat.completions.create(
model="plugsky-pro",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Extract only what was explicitly stated or clearly agreed. "
"Do not invent an owner or due date; use null. Every item needs a segment ID. "
"Keep decisions separate from suggestions and open questions. Return JSON."},
{"role": "user", "content": json.dumps({"schema": schema, "transcript": numbered})},
],
)
notes = json.loads(response.choices[0].message.content)
valid = {s["segment_id"] for s in segments}
for item in notes["actions"] + notes["decisions"] + notes["open_questions"]:
assert item["evidence"] and set(item["evidence"]) <= valid
The model will sometimes turn a polite suggestion into a committed action. Prompt for “proposed” versus “confirmed,” and require a human to confirm the list before it becomes a task. A null owner is useful: it flags that something needs an owner instead of fabricating a name.
CRM sync
Sync actions as tasks or activities and the summary to the account or opportunity timeline. Do not sync the raw transcript unless the customer agreed. The sync needs three properties:
- Idempotency: derive an external ID from the meeting, action index and a hash of the text. Upsert on that key; a retry must not duplicate a task.
- Ownership: map the extracted owner by email or directory ID, not display name. If ambiguous, leave the task unassigned and flag it.
- Approval: a human confirms the summary before it is written to a customer-facing field. Internal task creation can be automatic if policy allows.
import hashlib
def external_id(meeting_id, index, title):
raw = f"{meeting_id}:{index}:{title.strip().lower()}".encode("utf-8")
return "mtg-" + hashlib.sha256(raw).hexdigest()[:24]
# crm.tasks.upsert(external_id=external_id(...), fields={...})
Map title, owner, due date, status and source meeting, and send ISO dates. If the write fails, queue it and retry with the same external ID; log the response.
Retention and access
Meeting data can include pricing, personnel issues, customer health and legal strategy. Decide who can read the recording, transcript, summary and export, and apply the same rules to derived notes.
Set a retention window by data type. Audio, transcript, summary and CRM activity may need different periods. Support deletion by meeting and participant, and document how legal hold overrides deletion. If the recorder joins automatically, tell participants at the start and give them a way to object or leave. Verify the current requirements with counsel; this is not legal advice.
Cost per meeting
Cost has four parts: transcription, note extraction, storage and human review. Transcription is usually priced by audio minute; extraction by tokens. Measure both.
transcription_cost = audio_minutes * transcription_rate
input_tokens = audio_minutes * measured_tokens_per_minute
extraction_cost = input_tokens * input_rate + output_tokens * output_rate
review_cost = measured_review_minutes / 60 * loaded_hourly_rate
cost_per_meeting = transcription_cost + extraction_cost + review_cost + storage_cost
A one-hour meeting with four speakers can produce 8,000 to 12,000 words at typical speaking rates, roughly 11,000 to 16,000 tokens before the prompt and output. That fits in the 262,144-token context of Plugsky's main text models. Review time often surprises teams: confirming owners and dates for ten actions can take longer than the draft. Track review minutes, not just tokens. See pricing.
Evaluate
Use real meetings with human-written notes as the reference. Measure action recall, owner accuracy, date accuracy, decision accuracy, evidence validity and the false-action rate. A false action is worse than a missed one because it creates work nobody agreed to do.
Stratify by meeting type: stand-up, customer call, sales discovery, incident review. A clean two-person call may not predict an eight-person workshop. Review a sample monthly and re-run after a change. The output is a draft, not an official record.
FAQ
What should a meeting notes API return?
A short summary, action items with owner and due date, decisions with rationale, and open questions, each linked to the transcript segment that supports it. Keep the transcript and the derived notes separate.
How do I attribute speakers correctly?
Normalize diarization labels, map them to attendees from the calendar and participant list, and require a human to confirm ambiguous mappings. Do not infer an identity from voice or context alone.
Can the API write action items to my CRM?
Yes, with a stable external ID and an upsert so retries do not duplicate tasks. Map owners by directory ID, send ISO dates, and require approval before writing customer-facing notes.
How long should meeting recordings be retained?
Set separate retention windows for audio, transcript, summary and CRM activity, based on your policy and legal obligations. Support deletion by meeting and participant, and document how legal hold overrides deletion. Verify the current requirements with counsel.
How much does it cost to summarize a one-hour meeting?
Add transcription by audio minute, extraction tokens, storage for the retention period and human review time. A one-hour meeting is roughly 11,000 to 16,000 tokens of transcript; review time is often the larger operational cost.
Sources: the W3C WebVTT specification for timed text and RFC 8259 for JSON. Both checked 20 November 2026. Reviewed 20 November 2026. Recording consent, retention and employment requirements vary; this page is not legal advice.