Turn a Voice Memo into a GitHub Issue (and PR) with ElevenLabs Scribe

The best bug reports you will ever write are the ones you think of when you are not at a keyboard. The repro that becomes clear during the walk home. The feature idea that lands while driving. The fix that arrives in the shower. Most of those thoughts die in a Notes app draft or a voice memo that never gets re-listened to, because converting a rambling 60-second recording into a structured GitHub issue is work you will postpone forever.

The capture position is the hard part, not the transcription. This guide builds the honest version of the loop: speak the memo into your phone, transcribe it with the ElevenLabs Scribe speech-to-text API, hand the raw transcript to OpenCode running headless, and let it write the issue title, repro steps, and expected behavior - then file it with a label that a webhook agent can pick up and turn into a pull request while you sleep. We run a version of this shape for parts of this site; the mechanics below are the portable core. Seven steps, under an hour, every step ending in something you can run.

Official Sources#

Step 1: Install the two CLIs#

Prerequisites: an ElevenLabs account (the free tier includes 4 hours 30 minutes of Scribe transcription per month, per the API pricing table as of 2026-09-16 - enough for well over a hundred short memos a month), the GitHub CLI authenticated against a repo you own, and a phone or recorder that produces voice memos.

Install OpenCode with the official one-liner from the OpenCode docs, authenticate a provider (opencode auth login), then prove the single capability this pipeline depends on - one task, one exit, no TUI:

curl -fsSL https://opencode.ai/install | bash
opencode run --model opencode/deepseek-v4-flash "print the current directory tree, two levels deep"

If that returns a tree and exits cleanly, the agent side is ready. Scheduled and event-driven work is where budget models earn their keep - the fleet economics post covers when a task deserves a stronger model. What you have now: a working headless agent and a repo that can receive issues.

Step 2: Record the memo like a bug report#

The transcription quality depends more on how you speak than on which model runs - Scribe is excellent at cleaning up voice, but it cannot invent repro steps you did not say. For a bug: state the product, the action, the expected result, and the actual result, in that order. For a feature: the end state, the user, and one concrete example. Keep it to 30 to 90 seconds; that is plenty.

Use your phone's default voice memo app - the common export formats (M4A, MP3, WAV, OGG, FLAC, OPUS, WebM) are all accepted by the API, per the overview page. Save the file somewhere the terminal can reach it:

mkdir -p ~/memos
ls -lh ~/memos/

What you have now: one audio file on disk, 60-ish seconds long, that says everything the issue needs to say.

Step 3: Transcribe with Scribe#

The API reference documents the endpoint as a single multipart POST to https://api.elevenlabs.io/v1/speech-to-text, with the API key in the xi-api-key header and model_id as the one required field. The current model id is scribe_v2:

export ELEVENLABS_API_KEY="your_key_from_the_dashboard"

curl -fsSL -X POST "https://api.elevenlabs.io/v1/speech-to-text" \
  -H "xi-api-key: $ELEVENLABS_API_KEY" \
  -F "model_id=scribe_v2" \
  -F "file=@$HOME/memos/first-bug.m4a" \
  -F "no_verbatim=true" \
  | jq -r '.text' > ~/memos/first-bug.txt

Two flags do real work here. no_verbatim=true strips filler words, false starts, and disfluencies from the output - the reference documents it as supported only on scribe_v2, and it turns "so like, um, when I click the button, basically nothing happens" into "when I click the button, nothing happens". That is the difference between text you can paste into an issue and text you still have to edit. If you skip the flag, expect the transcript to contain every "um" you said.

The response also carries words with per-word start and end timestamps in seconds (useful later if you want to quote a stack trace by time), the detected language_code, and audio_duration_secs so you can see exactly what you were billed for. What you have now: the memo as clean text, on stdout, free of ums.

Step 4: Hand the transcript to the agent#

This is the step that makes the pipeline worth building: you never write the issue body. The transcript gets piped into opencode run, already verified headless in Step 1, with a prompt that forces structure:

opencode run --model opencode/deepseek-v4-flash \
  "You are filing a GitHub issue from raw dictation. Read the transcript below.
   Produce a file issue-body.md with: a title under 72 characters,
   numbered reproduction steps, expected behavior, and actual behavior.
   If the dictation describes a feature instead of a bug, say so plainly
   and structure the body around the end state.
   Transcript: $(cat ~/memos/first-bug.txt)"

Run it from any directory; the output is written to issue-body.md. The task is narrow and the gate is human review of a text file, so the cheapest reliable model is the honest choice - the OpenCode cron guide makes the same call for the same reason.

If the transcript contains product or library names the model keeps mangling (an uncommon word is exactly where STT and the agent both slip), that is what keyterms is for: up to 1000 terms, each under 50 characters, added to the request to bias transcription toward them, per the API reference. What you have now: issue-body.md, structured, in the repo's own terminology.

Step 5: File the issue - and let a webhook agent take it from here#

The gh issue create manual gives this pipeline three flags it actually needs: --title, --body-file, and --label. Use all three:

gh issue create --title "$(sed -n '1p' issue-body.md)" \
  --body-file issue-body.md \
  --label agent

The label is not decoration: it is the hook. The deploy-an-agent-webhook guide builds the receiving end - a small service on Railway that watches for issues labeled agent, runs a headless agent in a fresh checkout, passes your test suite, and opens a pull request. This guide produces the issue; that guide produces the PR. Ran end to end, your spoken bug report becomes a candidate fix you review later the same day. What you have now: a structured issue in the tracker, labeled for the automation, filed without typing.

Step 6: Make it survive real use#

A single memo is a demo; a month of memos is a system. Four refinements, each documented in the sources above:

1. Product names in every memo. If your transcript keeps mishearing a term, add it to keyterms once and keep it in your curl: the pricing table adds a $0.05 per audio hour surcharge for keyterm prompting, as of 2026-09-16 - a rounding error on short memos.
2. Multi-speaker sessions. Dictate a brainstorming session with a teammate into one recording and add diarize=true with num_speakers=2; the response annotates each word with a speaker_id, up to 32 speakers, per the API reference.
3. Recordings that live elsewhere. Instead of uploading, pass source_url with an HTTPS URL (pre-signed cloud storage links and video hosting URLs like YouTube and TikTok are accepted per the reference, which is how you build a "review this video" pipeline around the same API).
4. Long files come back async. Set webhook=true and the transcription result is delivered to the webhooks configured in your workspace when it finishes, rather than blocking your terminal - the right mode for the 40-minute product demo you will never re-record.

One honest warning about privacy: the API reference notes that zero-retention mode (enable_logging=false) is available to enterprise customers only. Anything you transcribe is stored per the platform's logging defaults, so keep confidential material out of this loop - it is for bugs and features, not for customer recordings containing secrets.

Step 7: The bill, and what you have now#

Scribe is billed per hour of audio, not per request: $0.22 per audio hour on the API pricing table, as of 2026-09-16, and the free tier's included 4 hours 30 minutes covers the casual memo habit completely. A 90-second memo costs under a cent of transcription. The agent's share is token-based and fractional on a budget model; at DeepSeek V4 Flash's $0.14/$0.28 per million tokens, a structured issue body is a fraction of a cent.

What you have now: the whole loop - speak, transcribe, structure, file. A thought captured at the moment you have it, in the exact words you had it, turning into an issue that a webhook agent can pick up and answer with a PR. The companion builds finish the circle: the audio briefs guide gives the same account a voice for reading results back, Wispr Flow covers the interactive dictation variant for when you are at the desk, and the release notes podcast turns the issues you shipped into audio your users will actually hear. Capture should be the cheapest step in the pipeline. Now it is.

FAQ#

What audio formats does the Scribe API accept?#

M4A, MP3, WAV, OGG, FLAC, OPUS and WebM audio, plus MP4, AVI, MKV, MOV, WMV, FLV, MPEG and 3GPP video files, per the Speech to Text overview. Files up to 3 GB and 10 hours of duration are supported in standard mode, as of 2026-09-16.

Does Scribe transcribe languages other than English?#

Yes. Scribe v2 transcribes 90+ languages and predicts the language automatically when language_code is not provided; you can also set an ISO-639-1/3 code to improve performance, and the response includes a language_probability confidence score, per the overview and the API reference.

Can I point Scribe at a URL instead of uploading a file?#

Yes. Pass source_url with any HTTPS-accessible audio or video URL, including pre-signed cloud storage links and hosted video URLs, per the API reference. Exactly one of file or source_url is required.

How much does a voice memo cost to transcribe?#

Scribe v2 is $0.22 per hour of audio, with optional surcharges of $0.05 per hour for keyterm prompting and $0.07 per hour for entity detection, per the API pricing table as of 2026-09-16. The free tier includes 4 hours 30 minutes of Scribe per month, which is roughly 180 ninety-second memos.

Is my recording private?#

Standard logging applies by default. Zero-retention mode exists (enable_logging=false) but is limited to enterprise customers per the API reference, so treat everything you transcribe as non-confidential unless you have an enterprise agreement.

Sources#

Some links to tools above are referral links - see our affiliate disclosure.

Last updated: September 16, 2026

Continue Reading#

• Make Your Coding Agent Talk: Audio Briefs from Agent Runs with ElevenLabs - the output side of the same account: agent summaries as MP3s
• Put an AI Agent Behind a Webhook: Turns GitHub Issues into Pull Requests - the receiving end this issue's label triggers
• Put an AI Agent on a Cron Job - the scheduled sibling: the same headless runner, a clock instead of your voice
• Give Your Coding Agent a Voice: Dictate Prompts with Wispr Flow - the interactive dictation loop, for when you are at the desk
• Podcast Your Release Notes with ElevenLabs - what the issues you file sound like after they ship