Free Hebrew transcription on your own computer

Note: general recommendations only, not professional advice. You are responsible for checking before use. Before you record a call or a meeting, tell the other side you're recording, and check with a lawyer what applies to you. The full text is at the end.

Who it's for

Small businesses, nonprofits and anyone with recordings piling up: calls with clients, team meetings, board meetings, interviews, WhatsApp voice notes. If you listen to a recording again just to write a summary, or never write one because there's no time, this kit is for you.

You don't need to know how to code. You need to copy a command, paste it into a window and press Enter. Every command is written out in full here, separately for Windows and for Mac.

What you'll have at the end of the hour

• Python and one library installed on your computer (faster-whisper), and the ivrit.ai Hebrew transcription model saved locally after a single download.
• A transcribe.py file that transcribes one file or a whole folder with one command.
• A text file next to every recording, with a timestamp at the start of each line, like [00:04:12], so it's easy to jump back to the exact moment in the recording.
• Six prompts that turn a transcript into a meeting summary, decisions and tasks, board meeting minutes, a row for your leads sheet, and call notes that go straight into the kit From call notes to a price quote.
• A tidy work habit: announcing the recording at the start of the call, checking names and numbers against the recording, and deleting it when you no longer need it.

Three paths, from easiest to most private

Path 1, the quickest: upload the recording to Gemini or ChatGPT. It works right away, with nothing to install. The downside: the recording leaves your computer for the company's servers. According to Google, on Gemini's free tier submitted content is used to improve its products, and on the paid tier it isn't. So this is not for sensitive calls. Terms change, so check each tool's current terms yourself before you upload anything.

Path 2, the heart of this kit: the ivrit.ai model on your own computer. ivrit.ai is an open Israeli project that trains models for Hebrew. The model ivrit-ai/whisper-large-v3-turbo-ct2 is Whisper fine-tuned on Hebrew, under the Apache-2.0 license, which allows business use too. You run it with the faster-whisper library. On the first run the model downloads once, about 1.6 GB. From then on your recordings don't leave the computer. It's free, with no subscription.

Path 3, after the transcript: prompts. You paste the text file into an AI tool (ChatGPT, Claude or Gemini) with one of the prompts, and get a summary, tasks or minutes. A cloud tool is fine here, because you control what you paste. If the call is sensitive, remove names, phone numbers, ID numbers and other identifying details from the transcript before you paste it.

Most of the steps below are Path 2. Step 1 is Path 1, for anyone who wants a result now, and Step 8 is Path 3.

What you need

• A Windows or Mac computer, with a few gigabytes free on the disk for the model.
• An internet connection, only for the install and the model download.
• One short recording to try, about 5 minutes. Any common format works: mp3, m4a, wav, ogg, opus (the format of WhatsApp voice notes), and video too, like mp4 or mov.
• A free AI tool for the last step: ChatGPT, Claude or Gemini.

About recording and consent, before anything else: at the start of a call or a meeting, say that you're recording and why. For example: "I'm recording the call so I don't miss details for the quote, is that OK with you?". What the law requires of you depends on the situation: a call with a client, with an employee, a meeting with residents or with volunteers. Check that with a lawyer, not with a guide. Two more decisions are worth making up front: how long you keep recordings and transcripts (only as long as needed), and who can see them.

The kit, step by step (60 minutes)

Step 1 (5 minutes): The quick path, if you need a transcript now

What to do: Open Gemini or ChatGPT, attach the recording and write:

Transcribe the attached recording in Hebrew, word for word. At the start of each segment write a timestamp in the format [hh:mm:ss]. If it's unclear what was said, write [unclear] and don't guess. Don't summarize and don't fix the wording.

How: If the tool doesn't accept the format, try the other tool, or convert the file to mp3. Check the result against the recording, especially names and numbers.

When not to: a call with medical, financial or personal details, a call with an employee about a sensitive matter, a closed meeting. For those, go to Step 2.

Step 2 (10 minutes): Install Python

What to do: Install Python 3.10 or newer. If you already have it, just check the version.

How on Windows:

1. Go to python.org, open Downloads, and download the Windows installer.
2. On the first screen of the installer tick Add python.exe to PATH, and click Install Now.
3. If the installer screen looks different, no problem. What matters is that the check in Step 3 works.

How on Mac:

1. The simplest way: download the macOS installer from python.org and install it as usual.
2. If you already use Homebrew, you can install through it (brew install python). Note the Homebrew remark in Step 4.

Common mistake: a Mac sometimes already has an old python3, version 3.9. The script needs 3.10 or newer. If the check in the next step shows 3.9, install a new version from python.org.

Which version: any version from 3.10 up should work. If a new version came out just a few weeks ago, packages sometimes take a while to catch up. In that case 3.12 is a safe choice.

Step 3 (5 minutes): Open a command window in a folder

What to do: Create one folder for all the work, for example transcripts inside Documents, and open a command window in it. Inside it create a subfolder recordings and put your test recording there.

How on Windows: Open the folder in File Explorer, click the address bar at the top, type cmd and press Enter. A black window opens, already inside the folder.

How on Mac: In Finder, right-click the folder (or Control-click) and choose Services > New Terminal at Folder. If the option isn't there, open Terminal, type cd (with a space at the end), drag the folder into the window and press Enter.

Check that everything is in place:

py --version

python3 --version

You should see a line like Python 3.12.7. Any number from 3.10 up is good.

Step 4 (5 minutes): Install faster-whisper

What to do: Run one install command. It installs faster-whisper and everything it needs, including the audio library. You don't need to install ffmpeg separately.

py -m pip install faster-whisper "av<19"

python3 -m pip install faster-whisper "av<19"

Why "av<19": faster-whisper reads audio files through a library called PyAV (av in the command). Its newest version, 19, breaks faster-whisper 1.2. We verified this on 22.10.2026: with PyAV 19 transcription fails with an error, and with a version below 19 it works. Adding "av<19" tells pip to install a version below 19. The quotes matter, because without them the window reads the < sign as something else. When faster-whisper releases a version that fixes this, you can drop it.

A note on Homebrew on Mac: if you see the error externally-managed-environment, you need a separate environment. Run these three lines, one after the other:

python3 -m venv ~/tx-env
source ~/tx-env/bin/activate
python3 -m pip install faster-whisper "av<19"

Every time you open a new window to transcribe, run source ~/tx-env/bin/activate first.

The install downloads a few dozen megabytes and takes a minute or two. You can ignore yellow messages about pip or PATH. What matters is a line at the end that starts with Successfully installed.

Step 5 (5 minutes): Save the script

What to do: Copy all of the code below, from the first line to the last, into a file named transcribe.py in the transcripts folder. You don't need to change any line.

How on Windows: Open Notepad, paste, and choose File > Save as. Under "Save as type" choose All files, name the file transcribe.py, and under encoding choose UTF-8.

How on Mac: In TextEdit first choose Format > Make Plain Text, and only then paste. Save as transcribe.py, with UTF-8 encoding. If TextEdit offers to add .txt, say no. If you have a code editor, like VS Code, you can save from there.

"""Hebrew transcription on your own computer, with the ivrit.ai open model (Apache-2.0).

Usage:
  python transcribe.py recording.m4a           one file
  python transcribe.py recordings/             every audio/video file in a folder
  python transcribe.py call.mp3 --words "שם הלקוח, שם המוצר"   names and terms that should be spelled right

Install once: pip install faster-whisper "av<19"   (av 19 breaks faster-whisper 1.2, so it stays below 19)
Writes next to each file: <name>.txt (with timestamps). Files that already have a .txt are skipped (--force redoes them).
The first run downloads the model (about 1.6 GB) once. After that nothing leaves the computer.
"""
import argparse
import sys
import time
from pathlib import Path

MODEL = "ivrit-ai/whisper-large-v3-turbo-ct2"
AUDIO = {".mp3", ".m4a", ".wav", ".ogg", ".opus", ".aac", ".flac", ".amr", ".wma", ".mp4", ".mov", ".webm", ".mkv"}


def stamp(seconds: float) -> str:
    s = int(seconds)
    return f"{s // 3600:02d}:{s % 3600 // 60:02d}:{s % 60:02d}"


def pick_device() -> tuple[str, str]:
    """A graphics card (NVIDIA) if there is one, otherwise the processor with a lighter number format."""
    try:
        import ctranslate2

        if ctranslate2.get_cuda_device_count() > 0:
            return "cuda", "float16"
    except Exception:
        pass
    return "cpu", "int8"


def out_path(path: Path) -> Path:
    """call.m4a -> call.txt; if call.mp3 sits next to it too, call.m4a -> call.m4a.txt so neither overwrites the other"""
    twins = [p for p in path.parent.glob(f"{path.stem}.*") if p != path and p.suffix.lower() in AUDIO]
    return path.with_name(f"{path.name}.txt") if twins else path.with_suffix(".txt")


def files_to_do(target: Path, force: bool) -> list[Path]:
    if target.is_file():
        files = [target]
    elif target.is_dir():
        files = sorted(p for p in target.iterdir() if p.is_file() and p.suffix.lower() in AUDIO)
    else:
        sys.exit(f"לא נמצא: {target}")
    return [f for f in files if force or not out_path(f).exists()]


def transcribe_file(model, path: Path, words: str | None) -> Path:
    segments, info = model.transcribe(
        str(path),
        language="he",
        vad_filter=True,  # skips long silences, faster and fewer made-up lines
        hotwords=words or None,
    )
    lines = []
    for seg in segments:
        text = seg.text.strip()
        if text:
            lines.append(f"[{stamp(seg.start)}] {text}")
            print(f"  {lines[-1]}", flush=True)
    out = out_path(path)
    out.write_text("\n".join(lines) + "\n", encoding="utf-8")
    return out


def main(argv=None) -> int:
    # Hebrew output on any console (Windows included)
    for stream in (sys.stdout, sys.stderr):
        try:
            stream.reconfigure(encoding="utf-8", errors="replace")
        except Exception:
            pass
    ap = argparse.ArgumentParser(description="תמלול עברית במחשב שלכם")
    ap.add_argument("target", help="קובץ שמע או וידאו, או תיקייה")
    ap.add_argument("--words", help="שמות ומונחים שחשוב שייכתבו נכון, מופרדים בפסיקים")
    ap.add_argument("--model", default=MODEL, help=f"ברירת מחדל: {MODEL}")
    ap.add_argument("--force", action="store_true", help="לתמלל מחדש גם קבצים שכבר יש להם .txt")
    args = ap.parse_args(argv)

    todo = files_to_do(Path(args.target).expanduser(), args.force)
    if not todo:
        print("אין קבצים חדשים לתמלל.")
        return 0

    from faster_whisper import WhisperModel

    device, compute = pick_device()
    print(f"טוען את המודל ({device}). בפעם הראשונה זה כולל הורדה, כמה דקות.")
    model = WhisperModel(args.model, device=device, compute_type=compute)

    failed = 0
    for path in todo:
        print(f"\n{path.name}")
        t0 = time.time()
        try:
            out = transcribe_file(model, path, args.words)
            print(f"נשמר: {out.name} ({int(time.time() - t0)} שניות)")
        except Exception as e:  # one bad file doesn't stop the rest
            failed += 1
            print(f"שגיאה בקובץ {path.name}: {e}")
    return 1 if failed else 0


if __name__ == "__main__":
    sys.exit(main())

What the script does, without the code:

• One file or a whole folder. Give it the name of a recording, or the name of a folder, and it goes through every audio and video file in it.
• Doesn't do the work twice. A recording that already has a .txt file next to it is skipped. To transcribe it again, add --force.
• Names and terms. With --words "client name, product name" you give the model a list of words that should be spelled right. It helps, but it's not a guarantee.
• The result is saved next to the recording. call.m4a becomes call.txt, and every line starts with a [hh:mm:ss] timestamp. If the same folder has two recordings with the same name in different formats, for example call.m4a and call.mp3, the file keeps the full name, call.m4a.txt, so one doesn't overwrite the other.
• One bad file doesn't stop the rest. It prints an error for that file and moves on to the next one.
• Skips silence. Long stretches with no speech aren't transcribed. That's faster, and means fewer made-up lines, which tend to appear in silence.
• Picks the hardware by itself. If the computer has an NVIDIA graphics card, it uses it. If not, it runs on the processor.

Step 6 (15 minutes): Transcribe a first recording

What to do: Run the script on your test recording. Say it's called test.m4a and sits in the recordings folder.

py transcribe.py recordings\test.m4a

python3 transcribe.py recordings/test.m4a

What happens: You'll see a line in Hebrew saying the model is loading (cpu), and that the first time includes a download of a few minutes. On the first run the model downloads, about 1.6 GB, and then lines of the transcript start appearing on screen, one after another. At the end you'll see a line in Hebrew that starts with "נשמר:" (saved) followed by test.txt and the number of seconds it took. The script's messages are in Hebrew; the commands and options are the same in any language.

How long it takes: it depends on the computer. That's why you start with a 5-minute recording and check how many seconds the "saved" line shows. From that you can estimate how long an hour of recording will take. On a computer with an NVIDIA graphics card it's much faster, and the script detects it by itself: then the first line says cuda instead of cpu.

Read the result: open test.txt in the recordings folder. Each line looks like this:

[00:00:00] שלום, מדבר אלון, אני מקליט את השיחה כדי לא לפספס פרטים, זה בסדר?
[00:00:06] כן, בטח.

(In English: "Hi, this is Alon, I'm recording the call so I don't miss details, is that OK?" / "Yes, sure.")

Common mistake: checking only the beginning. Go over the whole transcript against the recording, in three places: names, numbers (amounts, phone numbers, dates) and professional terms. That's where the model makes the most mistakes. The timestamp helps: you see [00:04:12] and skip there in the player.

Step 7 (5 minutes): Names, terms and a whole folder

What to do: If names or terms came out wrong in Step 6, transcribe again with --words. Then run on a whole folder.

py transcribe.py recordings\test.m4a --force --words "אלון, קרמיקה, אינטרפוץ, רמת גן"

python3 transcribe.py recordings/test.m4a --force --words "אלון, קרמיקה, אינטרפוץ, רמת גן"

--force is needed here because test.txt already exists. Without it the script would skip the file. The words go in Hebrew, the way you want them spelled in the transcript.

A whole folder: put all the recordings in the recordings folder, and run:

py transcribe.py recordings

python3 transcribe.py recordings

The script only transcribes what doesn't have a .txt yet. You can run the same command every evening, and it will handle only the new recordings.

WhatsApp voice notes: in WhatsApp for desktop, open the voice note and download it, or forward it to yourself and save the file. The files are usually .ogg or .opus, and the script knows both.

Step 8 (10 minutes): From transcript to output

What to do: Open the .txt file, copy the transcript, and paste it into an AI tool together with one of the prompts in the next section.

How:

1. Decide whether the call is sensitive. If it is, remove people's names, phone numbers, ID numbers, addresses and other identifying details from the transcript before pasting. In the text editor, find and replace does this quickly: for example every "Ronit" becomes "the client".
2. Pick a prompt for what you need: a summary, tasks, minutes, a sheet row, or call notes for a price quote.
3. Check the result against the transcript. Every prompt asks for a timestamp next to each decision and task, so it's easy to check.

Common mistake: trusting the summary without checking. An AI tool can "fill in" a task nobody said, or drop a caveat. The prompts forbid this, and prompt 6 checks for it, but the last check is yours.

When something doesn't work

Ready-made prompts

Paste the prompt, and paste the transcript in place of the brackets. All the prompts work in ChatGPT, Claude and Gemini. They're written in English here; you can paste them as they are with a Hebrew transcript, and ask for the output in Hebrew if you need it.

Here is a transcript of a meeting, with timestamps in the format [hh:mm:ss]. The transcript was created automatically and may contain mistakes in names and numbers.

[paste the transcript]

Write a summary in plain language:
1. In one sentence: what the meeting was about and who took part (only people mentioned in the transcript).
2. The main topics, up to 6 points, each up to two sentences.
3. What was decided. Next to each decision, the timestamp where it was said.
4. What is still open.
Rules: only what was said in the transcript. Don't add conclusions, recommendations or details that weren't said. If something is unclear or looks like a transcription mistake, write [to check: ...] instead of guessing.

Here is a transcript of a meeting, with timestamps.

[paste the transcript]

Pull out only decisions and tasks from the transcript.
First table, decisions: decision | who proposed it | timestamp.
Second table, tasks: task | owner | due date | timestamp.
Rules: owner and due date only if they were said explicitly. If not, write [not set]. Don't turn an idea that came up in conversation into a decision. If it's unclear whether something is a decision, put it in a separate list called "Unclear if decided".
At the end, a short WhatsApp message for the team with the tasks, owner and due date, without timestamps.

Here is a transcript of a meeting, with timestamps.

[paste the transcript]

Details I'm adding: name of the body: [name]. Date: [date]. Present: [names]. Absent: [names].

Write draft minutes, in a factual style:
- A heading, date, present and absent, from the details I gave.
- The agenda, by the topics that came up in the transcript, in the order they came up.
- For each topic: the gist of the discussion in three to five sentences, without personal quotes and without attributing opinions to people unless it was said as a formal proposal.
- Decisions, worded as "Resolved: ...", and if there was a vote, the result as it was said.
- Follow-up tasks: what, who, by when.
Rules: only what was said. Any unclear detail, write [to check: ...]. Don't invent a vote result. At the end, a list of all the [to check] items with their timestamps, so I can check them against the recording.

Here is a transcript of a call with a potential client, with timestamps.

[paste the transcript]

Return one row inside a code block, with a tab between columns, in exactly this order:
Date | Client name | Business | Phone | Email | Lead source | What they asked for | Quote amount before VAT | Missing from the quote | Status | Follow-up date | Notes
Rules: only details that were said in the call. A column with no information stays empty, but the tab stays. Quote amount: leave it empty, I fill it in after I prepare a quote. Status: "New". No tabs or line breaks inside a cell.
Below the block, two lines: what the client wants most, and what worries them most, each with a timestamp.

Here is a transcript of a call with a client, with timestamps.

[paste the transcript]

Write short call notes, which I'll paste later into a prompt that prepares a price quote. In this format:
Client: name, business, city, phone and email (only what was said).
How they found us: ...
What they asked for: a list, one line per service or product, with quantities and sizes only if they were said.
Dates they asked for: worded as "The client asked: ...".
Budget or price mentioned: only if the client said a number.
Questions the client asked: ...
What's unclear and worth checking: ...
Rules: don't write any of my prices and don't suggest a price. Don't turn "about" into an exact number. Next to each item, the timestamp where it was said.

Go over what you wrote above, item by item. For each item (decision, task, number, name, date) write: the item, the timestamp, an exact quote from the transcript that it rests on, and "supported" or "not supported".
Then a separate list: numbers, names and terms that look like transcription mistakes, so I can check them against the recording.
Don't change what you wrote and don't add items.

Full example: Alon Renovations (a fictional business)

Everything in this example is fictional: the business, the client, the names, the numbers and the details.

Alon runs a small renovation business in Ramat Gan. He talks to clients on the phone, and until now he wrote the summary in his head, or on a note on the way to the next site. Half the details got lost.

He set up the kit on a Friday morning. On Sunday Ronit called, a client who got his number from her neighbor. At the start of the call he said: "I'm recording the call so I don't miss details for the quote, is that OK with you?". Ronit agreed.

In the evening he moved the recording from his phone to the recordings folder and ran:

py transcribe.py recordings\ronit-bathroom.m4a --words "אלון, רונית, קרמיקה, אינטרפוץ, ספייסר"

A few minutes later he had a file ronit-bathroom.txt. An excerpt, in Hebrew as the script wrote it:

[00:00:00] שלום, מדבר אלון, אני מקליט את השיחה כדי לא לפספס פרטים בהצעה, זה בסדר מבחינתך?
[00:00:05] כן, בטח. קיבלתי את המספר שלך מדנה, השכנה מהקומה השלישית.
[00:00:11] מעולה. אז מה רוצים לעשות?
[00:00:13] שיפוץ של חדר האמבטיה. להוריד את האמבטיה ולשים מקלחון, להחליף את כל הקרמיקה, ואסלה תלויה.
[00:00:24] כמה גדול החדר, בערך?
[00:00:27] משהו כמו שניים על שניים וחצי. אני יכולה לשלוח לך תמונות.
[00:01:02] ומתי הייתם רוצים להתחיל?
[00:01:05] בתחילת נובמבר, ושזה ייגמר לפני שההורים שלי מגיעים באמצע דצמבר.
[00:01:40] יש לנו תקציב של בערך עשרים אלף, זה ריאלי?
[00:01:46] אני צריך לראות את החדר. אני יכול לבוא ביום שלישי בבוקר?
[00:01:51] יום שלישי בשמונה וחצי מתאים. רחוב הרימון 12, דירה 7.

The same excerpt in English:

[00:00:00] Hi, this is Alon, I'm recording the call so I don't miss details for the quote, is that OK with you?
[00:00:05] Yes, sure. I got your number from Dana, the neighbor on the third floor.
[00:00:11] Great. So what would you like to do?
[00:00:13] Renovate the bathroom. Take out the bathtub and put in a shower, replace all the tiles, and a wall-hung toilet.
[00:00:24] How big is the room, roughly?
[00:00:27] Something like two by two and a half. I can send you photos.
[00:01:02] And when would you like to start?
[00:01:05] At the beginning of November, and have it finished before my parents arrive in mid-December.
[00:01:40] We have a budget of about twenty thousand, is that realistic?
[00:01:46] I need to see the room. Can I come on Tuesday morning?
[00:01:51] Tuesday at eight thirty works. 12 HaRimon Street, apartment 7.

Alon went over the transcript against the recording. He fixed two things: "HaRimon" came out wrong as "HaRmon", and the apartment number needed checking. It took five minutes.

The call wasn't especially sensitive, but it had an address and a phone number. Before pasting the transcript into ChatGPT, he replaced the address with "[address]" and the phone number with "[phone]". He entered both into the sheet himself. Then he ran prompt 5 and got:

Client: Ronit, Ramat Gan, [phone]
How they found us: referral from Dana, a neighbor (00:00:05)
What they asked for:
- Remove the bathtub and install a shower (00:00:13)
- Replace all the tiles in the bathroom, the room is about 2 by 2.5 meters (00:00:13, 00:00:27)
- Install a wall-hung toilet (00:00:13)
Dates they asked for: The client asked: to start at the beginning of November and finish before mid-December (00:01:05)
Budget or price mentioned: "about twenty thousand" (00:01:40)
Questions the client asked: whether the budget is realistic (00:01:40)
What's unclear and worth checking: exact room size, type of tiles, what happens with the sink and the cabinet. A site visit was set: Tuesday, 8:30 (00:01:51)

Alon pasted these notes as they are into the main prompt of the kit From call notes to a price quote, together with his price list. The quote came out with his own prices, and the shower line stayed [to fill: measurements] until the visit on Tuesday.

And prompt 4 gave him a row for the leads sheet:

11/10/2026	Ronit		[phone]		Referral from a neighbor	Bathroom renovation: shower, tiles, wall-hung toilet		Measurements, type of tiles	New	13/10/2026	Budget about 20 thousand; finish before mid-December; visit on Tuesday 8:30

Notice three things: "about twenty thousand" stayed "about", and didn't become an amount in the quote. The date was recorded as the client's request, not as Alon's commitment. And every item got a timestamp, so when Ronit asks "did I say a wall-hung toilet?", Alon will find it in a second.

After the quote was sent and closed, Alon deletes the recording. The transcript stays in the client's folder, and only he can see it.

One-page checklist

• You decided what goes to Path 1 (the cloud) and what only to Path 2 (your computer)
• At the start of every recording you say that you're recording and why, and you checked with a lawyer what applies to you
• py --version or python3 --version shows 3.10 or newer
• faster-whisper is installed with "av<19"
• transcribe.py is saved in the folder, with UTF-8 encoding
• A 5-minute recording was transcribed, and you know how long it took on your computer
• Recurring names and terms go into --words
• Every transcript is checked against the recording: names, numbers, terms
• Before pasting into a cloud AI tool, identifying details are removed from sensitive calls
• Every summary went through prompt 6
• You decided how long you keep recordings and transcripts, and who sees them

What's next

This kit works by hand: you move a recording into a folder, run a command, paste a prompt. The same process can be connected so new recordings are transcribed on their own every evening, the summary and tasks reach you as a message, and the row lands in the sheet. The recordings still don't leave the computer.

Disclaimer

This content is general recommendations only, not professional, legal, accounting or tax advice. Every business and organization is different. You are responsible for checking that it fits your situation, and for checking the commands, prompts and code before you use them.

Recording a call or a meeting, and keeping recordings and transcripts, may be subject to privacy law and other laws, and these depend on the situation: who takes part, where, and for what purpose. This content does not explain what the law requires. Before you record calls with clients, employees, residents or volunteers, consult a lawyer. In any case, tell the other side at the start of the call that you're recording and why, keep recordings and transcripts only as long as needed, and decide who can see them.

Automatic transcription can be wrong, especially with names, numbers, professional terms and noisy stretches. Summaries written by an AI tool can also be wrong or leave things out. Check names, numbers and anything important against the recording before you rely on them.

The ivrit.ai model, the faster-whisper library and all the other tools are open source or third-party services. They may change, be updated or stop working as described here, and their use is subject to their own licenses and terms. The terms of use and privacy of cloud AI tools change, so check them at the source.