---
title: "Arabic meeting minutes from audio - build it with an API"
description: "Turn Arabic meeting recordings into minutes with decisions and action items: transcribe, clean, summarise with an LLM into JSON, and check names and dates."
url: https://broadrouter.com/blog/arabic-meeting-minutes-from-recordings/
lang: en
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

# Arabic meeting minutes from recordings: an API pipeline

By the BroadNet Inference team · 6 min read · Published 2026-11-15

To make Arabic meeting minutes with an API, transcribe the recording with an Arabic speech-to-text model, split long transcripts into sections, ask an LLM for decisions, action items and open questions as JSON, then merge the sections. Have the model quote the transcript for every action item, and write the minutes in Modern Standard Arabic or English.

## Key takeaways

-   Minutes are two jobs: speech to text, then summarising. Choose and test each model separately.
-   Long meetings need chunking twice: the audio to fit the upload limit, and the transcript to keep the summary accurate.
-   Ask for JSON with a quote from the transcript for every decision and action item, so a reviewer can check each one.
-   A plain-text transcript has no speaker labels. Do not let the model guess who owns a task unless a name is spoken.
-   On BroadNet, an hour of Arabic audio costs $0.25 to transcribe; Qwen3.8 27B, tested by BroadNet in Arabic, writes the minutes.

**On this page**

1.  What does the pipeline look like?
2.  Step 1: how do you transcribe a long Arabic meeting?
3.  Can you get speaker names?
4.  Step 2: why split the transcript before summarising?
5.  Step 3: which model should write the minutes?
6.  Step 4: what prompt gives reliable minutes?
7.  Step 5: how do you merge sections into one set of minutes?
8.  What does one meeting cost?
9.  What mistakes should you avoid?
10.  When is an API pipeline the wrong choice?
11.  Where BroadNet Inference fits

Meeting minutes look like one task, but they are two: turning speech into text, and turning text into decisions and action items. Each step fails in its own way. A dialect word mis-transcribed becomes a wrong action item; a model that summarises well can still invent an owner. This post builds the pipeline for Arabic meetings and shows where to put the checks.

## What does the pipeline look like?

```text
recording (.m4a, .mp4, .webm)
  → ffmpeg: 16 kHz mono, split at silences
  → speech to text, language=ar, one request per chunk
  → join the transcript, clean obvious noise
  → split the transcript into sections
  → LLM: summary, decisions, action items, open questions (JSON) per section
  → LLM: merge the sections into one set of minutes
  → human review → send
```

The rest of this post goes step by step.

## Step 1: how do you transcribe a long Arabic meeting?

A one-hour meeting recorded on a laptop is usually far bigger than an upload limit. BroadNet Inference takes WAV or MP3 up to 26,214,400 bytes per file, so convert to 16 kHz mono and split at silences first. [Transcribe long audio over 25 MB](https://broadrouter.com/blog/transcribe-long-audio-files-api/) has the full script, including parallel requests and joining the text in order.

Three settings matter for Arabic meetings:

-   **Send `language="ar"` on every chunk.** BroadNet’s docs warn that Arabic can otherwise come back transliterated into Latin letters.
-   **Use the Arabic model** for Arabic-led meetings: `broadnet/cohere-transcribe-arabic`. For meetings mostly in another of its languages, `broadnet/cohere-transcribe` costs $0.002 a minute.
-   **Keep the raw transcript.** You need it for review and for the quotes in step 4.

Mixed Arabic and English is normal in Gulf business meetings. Test a recording with your usual mix: English product names and numbers are where errors show up. [Arabic dialect speech recognition](https://broadrouter.com/blog/arabic-dialect-speech-recognition/) covers what to listen for.

## Can you get speaker names?

Not from a plain-text transcript. BroadNet’s transcription response is JSON with one `text` field: no speakers and no timestamps. (For caption timing from chunk offsets, see [Arabic subtitles from a text-only API](https://broadrouter.com/blog/arabic-subtitles-srt-api/).) You have three options:

| Situation | What to do |
| --- | --- |
| Each person recorded on a separate track or channel | Transcribe each track on its own; the track tells you the speaker |
| Two-channel call recording | Split the channels with ffmpeg, as in the [call center pipeline](https://broadrouter.com/blog/transcribe-call-center-recordings/) |
| One mixed track, and you need speakers | Use a provider that returns [diarization](https://broadrouter.com/glossary/diarization/); the [buyer’s guide](https://broadrouter.com/blog/arabic-speech-to-text-api-buyers-guide/) compares them |

With one mixed track, the LLM can still find owners when someone says a name: “Khalid will send the quote by Thursday.” What it must not do is guess an owner from context. The prompt below forbids that.

## Step 2: why split the transcript before summarising?

Two reasons. First, context: an hour of talk can be too long for a small model. [BroadNet Gemma 4 VL 26B](https://broadrouter.com/models/gemma-4-vl-26b/) has a 32,768-token context, which a long Arabic meeting can exceed. Count yours with the [Arabic token counter](https://broadrouter.com/tools/arabic-token-counter/); Arabic usually needs more tokens per word than English, as [tokens per word in Arabic vs English](https://broadrouter.com/blog/tokens-per-word-arabic-english/) shows.

Second, accuracy. Research on long inputs found that model performance “significantly degrades when models must access relevant information in the middle of long contexts” ([Liu et al.](https://arxiv.org/abs/2307.03172)). A decision made in minute 35 of 70 is exactly that. Summarising sections of 10 to 15 minutes each, then merging, keeps every part near the start of a prompt.

Split on the same silence points you used for the audio, so a section never starts mid-sentence.

## Step 3: which model should write the minutes?

| Model | Context | Notes for minutes | Input / output per 1M tokens |
| --- | --- | --- | --- |
| [Qwen3.8 27B](https://broadrouter.com/models/qwen3.8-27b/) | 262,144 | Tested by BroadNet in Arabic: fluent writing, Gulf and Egyptian dialects understood; structured output listed | $0.175 / $2.17 |
| [GLM 5.3](https://broadrouter.com/models/glm-5.3/) | 1,048,576 | Structured output listed; text only | $0.78 / $3.46 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/models/deepseek-v4.1-flash/) | 1,048,576 | Also on a flat plan at $60 a month per session, one request at a time | $0.175 / $0.52 |

Start with Qwen3.8 27B, because it is the model BroadNet tested in Arabic. Test it against one other model on three real meetings, and have a native speaker score them. [Choosing an LLM for Arabic](https://broadrouter.com/blog/choosing-an-llm-for-arabic/) has a scoring sheet.

All three models reason before they answer, and the reasoning counts toward `max_tokens`. Minutes are long, so allow several thousand tokens, or the visible answer can come back empty. [Why that happens](https://broadrouter.com/guides/reasoning-tokens-empty-response/).

## Step 4: what prompt gives reliable minutes?

Ask for JSON, and make the model quote the transcript for every item. The quote is what lets a reviewer check an action item in seconds instead of rereading the whole transcript.

```python
import json, os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

SYSTEM = """You write meeting minutes from an Arabic meeting transcript section.
Return JSON only, with these keys:
  "summary": 2-4 sentences in Modern Standard Arabic,
  "decisions": [{"text": ..., "quote": ...}],
  "actions": [{"task": ..., "owner": ..., "due": ..., "quote": ...}],
  "open_questions": [{"text": ..., "quote": ...}]
Rules:
- "quote" is the exact words from the transcript that support the item.
- "owner" is a name only if the transcript says who will do it. Otherwise null.
- "due" only if a date or day is said. Keep it as said, e.g. "الخميس". Otherwise null.
- Keep names, numbers and amounts exactly as in the transcript. Never guess."""

def minutes_for(section):
    r = client.chat.completions.create(
        model="broadnet/qwen3.8-27b",
        max_tokens=4000,
        messages=[{"role": "system", "content": SYSTEM},
                  {"role": "user", "content": section}])
    return json.loads(r.choices[0].message.content)
```

Then validate in code. Parse the JSON, check the keys, and check that every `quote` really appears in the section. An item whose quote is not in the transcript is the model’s invention: drop it or flag it. If the JSON does not parse, retry once with the error message. [JSON mode vs json\_schema](https://broadrouter.com/blog/structured-output-json-schema/) shows a validation loop; BroadNet’s docs list structured output for GLM 5.3 and Qwen3.8 27B without naming the request parameter, so test it before relying on it.

For minutes in English, change the summary line to English and add: “Keep each quote in the original Arabic.” The [Arabic prompt engineering](https://broadrouter.com/blog/arabic-prompt-engineering/) post covers register, numerals and mixed-script text in more depth.

## Step 5: how do you merge sections into one set of minutes?

Send all the section results in one final request and ask the model to:

1.  Write one summary of the whole meeting.
2.  Merge duplicate decisions and actions. The same task is often mentioned twice.
3.  Keep each item’s quote.
4.  Mark an action as changed if a later section changes its owner or date.

The merge input is small: JSON from each section, not the transcript. A merge on any of the three models above stays far inside its context.

## What does one meeting cost?

| Step | What you pay for | Price |
| --- | --- | --- |
| Transcription | Audio minutes | $0.0042 a minute, $0.25 an hour |
| Section summaries | Transcript tokens in, JSON out | Qwen3.8 27B: $0.175 in, $2.17 out per 1M |
| Merge | Small JSON in and out | Same rates |

Transcription is usually the fixed part. The LLM part depends on transcript length and on how much the model reasons. Read `prompt_tokens` and `completion_tokens` from the first few real meetings, then multiply in the [LLM API cost calculator](https://broadrouter.com/tools/llm-api-cost-calculator/). The [speech-to-text cost calculator](https://broadrouter.com/tools/speech-to-text-cost-calculator/) does the audio side. The starting credit of $5 covers the transcription models, which is about 1,190 minutes of Arabic; Qwen3.8 27B needs a top-up.

## What mistakes should you avoid?

-   **Summarising the whole meeting in one prompt.** Items from the middle go missing.
-   **Letting the model fill gaps.** Owners and dates that were never said are the most common error in AI minutes. Make null the default.
-   **Translating too early.** Transcribe and extract in Arabic, then translate the minutes. Translating the transcript first loses the exact quotes.
-   **Skipping review.** Minutes are a record. A person who attended should read them before they go out.
-   **Keeping recordings forever.** Delete audio once the minutes are approved, unless you must keep it.

## When is an API pipeline the wrong choice?

If you need live captions during the meeting, speaker labels from one mixed track, or a ready-made app your team can use today, a dedicated meeting product is the faster route. Several sell Arabic meeting notes; compare them on your own recordings, since accuracy claims on their pages are their own. The API route makes sense when you want minutes inside your own system, in your format, with your own retention rules.

## Where BroadNet Inference fits

BroadNet puts both halves on one OpenAI-compatible key: BroadNet Transcribe Arabic at $0.0042 a minute, and Arabic-tested Qwen3.8 27B for the minutes. Its privacy statement says it keeps no prompts, audio, answers or transcripts after a request, which matters for internal meetings. It does not return speaker labels or timestamps, and it has no live transcription, so use another provider if you need those. Start with the [Arabic speech-to-text guide](https://broadrouter.com/guides/arabic-speech-to-text-api/), then add the summary step above.

Free tools for this

-   [Arabic token counter](https://broadrouter.com/tools/arabic-token-counter/) Arabic vs English token counts per tokenizer: the "Arabic tax" in tokens and money.
-   [Arabic text normalizer](https://broadrouter.com/tools/arabic-text-normalizer/) Tashkeel, tatweel, alef, ya, ta marbuta, digits and invisible characters, with a matching Python function.
-   [Speech-to-text cost calculator](https://broadrouter.com/tools/speech-to-text-cost-calculator/) Hours, calls or voice notes to a monthly transcription bill, against your current provider.

[All free tools](https://broadrouter.com/tools/)

## Terms in this article

[Token](https://broadrouter.com/glossary/token/)

A token is the unit of text a language model reads and writes: a word, part of a word, a punctuation mark or a byte sequence produced by the model's tokenizer. LLM APIs count, limit and usually bill usage in tokens.

[Speech-to-text](https://broadrouter.com/glossary/speech-to-text/)

Speech-to-text, also called automatic speech recognition (ASR), is technology that converts spoken audio into written text. A speech-to-text API accepts an audio file or stream and returns a transcript, usually priced per minute of audio. Accuracy is measured with word error rate and varies with accent, dialect and recording quality.

[Structured output](https://broadrouter.com/glossary/structured-output/)

Structured output is an LLM API feature that constrains a model's reply to a format the developer specifies, usually a JSON Schema, so code can parse it reliably. It is stricter than JSON mode, which guarantees valid JSON but not a particular shape.

[Tool calling](https://broadrouter.com/glossary/tool-calling/)

Tool calling, also called function calling, is an LLM API feature in which the model returns a structured request to run a function the developer has defined, with JSON arguments. The application runs the function and sends the result back; the model never runs code itself.

[Speaker diarization](https://broadrouter.com/glossary/diarization/)

Speaker diarization is the task of dividing an audio recording into segments by speaker, answering "who spoke when". It labels each stretch of speech with an anonymous speaker ID such as SPEAKER\_00, and is usually combined with a transcript to show which person said each line.

[Concurrency](https://broadrouter.com/glossary/concurrency/)

Concurrency is the number of requests a client has in flight at the same time. LLM APIs often cap it per key or plan, separately from requests per minute, because each open request holds GPU capacity until its response has finished.

[Dialectal Arabic](https://broadrouter.com/glossary/dialectal-arabic/)

Dialectal Arabic is the everyday spoken Arabic of a region or city, such as Egyptian, Gulf, Levantine or Maghrebi Arabic. Dialects differ from Modern Standard Arabic in sounds, words and grammar, have no standard spelling, and are increasingly written online, which makes them harder for language models.

[JSON mode](https://broadrouter.com/glossary/json-mode/)

JSON mode is an LLM API setting, response\_format {"type": "json\_object"} in OpenAI-style APIs, that makes the model's reply valid, parseable JSON. Unlike structured outputs with a JSON Schema, it does not guarantee which keys, types or values the object contains.

## Questions

### How do I get meeting minutes from an Arabic recording?

Transcribe the audio with an Arabic speech-to-text API, sending language=ar. Then send the transcript to an LLM with a prompt that asks for a short summary, decisions, action items with owners and due dates, and open questions as JSON. Review the result before you send it.

### Can the minutes be in English when the meeting was in Arabic?

Yes. Transcribe in Arabic, then ask the LLM to write the minutes in English while keeping names, figures and quotes exactly as spoken. Keep the Arabic quotes so a bilingual reviewer can check the translation.

### How do I handle dialect in meeting minutes?

Let the transcript keep the dialect, because that is what was said. Ask the LLM to write the minutes in Modern Standard Arabic, and to keep dialect words in quotes when the meaning matters, such as a commitment or a refusal.

### Can an API tell who said what?

Only if it returns speaker labels. BroadNet's transcription returns plain text. If each participant is recorded on a separate track or channel, transcribe each track on its own and you know the speaker; otherwise use a provider with diarization.

### Which model should summarise a long meeting?

Pick a model with enough context for your longest transcript and good Arabic. On BroadNet, Qwen3.8 27B is the Arabic-tested model with a 262,144-token context; GLM 5.3 and DeepSeek V4.1 Flash take 1,048,576 tokens. Test two on three real meetings.

### Is it safe to send internal meetings to an API?

Check the provider's retention terms first. BroadNet states it keeps no prompts, audio, answers or transcripts after a request. Still remove anything the minutes do not need, such as personal phone numbers read aloud.

## Keep reading

-   [Transcribe long audio over 25 MB: split, send and stitch](https://broadrouter.com/blog/transcribe-long-audio-files-api/)
-   [Arabic speech-to-text API: how to choose one in 2026](https://broadrouter.com/blog/arabic-speech-to-text-api-buyers-guide/)
-   [How to transcribe call center recordings: an Arabic-ready pipeline](https://broadrouter.com/blog/transcribe-call-center-recordings/)
-   [JSON mode vs json\_schema: structured output that holds up](https://broadrouter.com/blog/structured-output-json-schema/)
-   [Choosing an LLM API for Arabic: what to test](https://broadrouter.com/blog/choosing-an-llm-for-arabic/)
-   [Arabic prompt engineering: register, RTL, numerals and mixed text](https://broadrouter.com/blog/arabic-prompt-engineering/)
-   [Arabic text summarization with an LLM: prompts, length and scoring](https://broadrouter.com/blog/arabic-text-summarization-llm/)
-   [Arabic subtitles (SRT) from a speech-to-text API: what you need](https://broadrouter.com/blog/arabic-subtitles-srt-api/)
-   [Add diacritics to Arabic text with an LLM: prompt, checks, DER](https://broadrouter.com/blog/arabic-diacritization-llm/)
-   [Arabic grammar and spelling correction with an LLM: a how-to](https://broadrouter.com/blog/arabic-grammar-spelling-correction-llm/)
-   [Guide: Arabic speech-to-text API, step by step](https://broadrouter.com/guides/arabic-speech-to-text-api/)
-   [Guide: Why a reasoning model returns an empty answer](https://broadrouter.com/guides/reasoning-tokens-empty-response/)

Try it on your real workload. New accounts start with $5 of credit for Gemma and transcription. DeepSeek, GLM and Qwen3.8 need a top-up.

[Get started](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-arabic-meeting-minutes-from-recordings&utm_content=page-cta) ·

**Sources**

-   [BroadNet Inference API reference: transcription fields and text-only response, models with structured output, reasoning and max\_tokens (checked 2026-11-15)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-arabic-meeting-minutes-from-recordings&utm_content=sources)
-   [BroadNet Inference pricing page: per-minute prices and the Qwen3.8 27B "Tested in Arabic" note (checked 2026-11-15)](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-arabic-meeting-minutes-from-recordings&utm_content=sources)
-   [BroadNet inference privacy statement: no prompts, audio or transcripts retained (checked 2026-11-15)](https://www.broadnet.ai/inference-privacy)
-   [Liu et al., Lost in the Middle: How Language Models Use Long Contexts (arXiv 2307.03172; checked 2026-11-15)](https://arxiv.org/abs/2307.03172)
-   [OpenAI speech to text guide: avoid splitting audio mid-sentence (checked 2026-11-15)](https://developers.openai.com/api/docs/guides/speech-to-text)
