← Back to blog

Transcribe Audio with a Whisper API — Speech-to-Text for AI Agents

Your meeting recording is 40 minutes long, and your agent has no idea what was said. You could drop it into a paid transcription SaaS, fight an export flow, and then copy-paste the result into a prompt. Or you could send one POST request and get back clean text, timed chunks, and even SRT subtitles — ready to feed straight into a summary, a RAG index, or a searchable archive.

The Agent Media Tools API exposes a Whisper-powered speech-to-text endpoint at /api/transcribe. It accepts either a direct audio upload or a public URL, returns the transcript with language detection and timestamped segments, and generates SRT subtitles when the upstream result includes timed chunks. One call each day is free, so it costs nothing to wire into your own scripts and evaluate it on your real files.

What the speech-to-text API returns

The endpoint returns a JSON object with everything an agent needs to do something useful with the audio:

• text — the full transcript as a string
• language — the inferred language of the source audio
• chunks — timestamped segments (with start/end times and per-segment text)
• srt — ready-to-use SRT subtitle text when timed chunks are available
• duration — the audio duration when the upstream model reports it
• billing — the quota and credit accounting for the call

That srt field is the quiet killer feature: you do not have to assemble subtitle files yourself. For agents that caption videos or auto-subtitle recordings, this turns a two-step workflow into a single request.

Option 1: Transcribe a local file with curl

Upload a local audio file with a multipart form field named audio:

curl -F "audio=@meeting.mp3" \
  https://agentmediatools.com/api/transcribe

Direct uploads are capped at 20 MB. That comfortably covers short calls, voice notes, and interview clips; for longer files, use the URL method below so the server pulls the source directly.

You can also request word-level timestamps instead of the default segment level:

curl -F "audio=@interview.wav" \
  -F "chunk_level=word" \
  https://agentmediatools.com/api/transcribe

Option 2: Transcribe a public URL with curl

When the audio is already hosted — a podcast episode, a lecture recording, an MP3 behind a public link — send the URL in a JSON body instead:

curl -X POST https://agentmediatools.com/api/transcribe \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/podcasts/episode-42.mp3"}'

Both url and audio_url are accepted as body fields, and this path avoids the 20 MB upload ceiling. This is the pattern to prefer for anything longer than a few minutes.

Option 3: Call it from Python with requests

For a scheduled job or an agent loop, the requests library keeps it to a few lines. Uploading a local file:

import requests

resp = requests.post(
    "https://agentmediatools.com/api/transcribe",
    files={"audio": open("meeting.mp3", "rb")},
)
data = resp.json()
print(data["text"])

Or transcribing from a URL:

import requests

resp = requests.post(
    "https://agentmediatools.com/api/transcribe",
    json={"url": "https://example.com/lecture.mp3"},
)
data = resp.json()
print(data["language"], data["duration"])
print(data["srt"][:500] if data.get("srt") else "no subtitles")

For recurring work, add explicit timeouts and bounded retries around transient failures, and inspect the returned error before retrying.

Send the transcript to an LLM in one pipeline

The transcript is designed to be consumed programmatically, so chaining it into an LLM summary is straightforward:

import json
import requests

def transcribe(url):
    r = requests.post(
        "https://agentmediatools.com/api/transcribe",
        json={"url": url},
    )
    r.raise_for_status()
    return r.json()["text"]

text = transcribe("https://example.com/all-hands.mp3")

# Then pass `text` to your model of choice for a summary,
# action items, or a searchable archive entry.
print(f"Transcribed {len(text.split())} words")

The same pattern can feed meetings into a search index, move interview audio into a RAG pipeline, or prepare support-call transcripts without operating a local Whisper installation.

Calling it from an MCP agent

If your agent talks MCP, the hosted server exposes the same capability as the transcribe_audio tool. Pass a public audio_url and an optional chunk_level (segment or word), and the tool returns the full JSON — transcript, language, chunks, and SRT — straight into your agent's context. See the Claude + MCP setup guide for how to connect a desktop agent to the hosted MCP server.

Pricing and quota

Transcription is metered per call:

• Free tier: the first call each day is free for anonymous and free-account users.
• After that: each attempt uses 2 flexible credits.
• Higher-volume keys: premium agent keys receive a much larger daily free allowance (30 free calls per day) before credit metering applies.

Successful responses include a billing object. Rejected quota or credit checks return a structured error and billing details where available; invalid-input and upstream failures can have a different error shape. Check the HTTP status and success field before reading transcript fields.

Practical limits worth knowing

• Upload size: multipart uploads are limited to 20 MB; use the URL method for larger source files.
• Input: the endpoint accepts standard audio files; when you pass a URL, it should point to a directly downloadable audio file rather than a streaming page.
• Timestamps: chunks and SRT are returned when the upstream model produces timed segments — most runs do, but treat srt as best-effort rather than guaranteed.

Build it into your workflow today

Speech-to-text is one of those capabilities that looks like a project until you have it as a single HTTP call. Start with your own meeting recording, grab the transcript in JSON, and wire it into the summary step of your agent — then add captioning or archival once you see how cheap the loop is.

Try the Speech to Text tool in the toolbox, or hit the endpoint directly from your own code.