Audio Extractor — Mono Speech Files

This audio extractor converts authorized direct audio or video file URLs into downloadable 16 kHz mono WAV artifacts for recurring ASR preprocessing. Each successful file includes verified encoding metadata, duration, a checksum and a hosted download link. It does not transcribe speech or download social-platform pages.

What does this audio extractor do?

It downloads a bounded media file, selects the first audio stream, resamples it to 16,000 Hz, downmixes to one channel and encodes signed 16-bit little-endian PCM in a WAV container. Metadata is removed from the output audio. There is no loudness normalization, denoising, silence removal or language detection.

Who is it for?

• ASR engineers preparing repeatable speech-recognition inputs.
• Research teams standardizing authorized interview recordings.
• Automation developers connecting a media archive to a transcription pipeline.

Why use it?

The deliverable is an audio file, not a transcript or just an original media URL. Verify the output rate, channel count and checksum before passing the artifact to your speech service. Each run has isolated storage and predictable safety limits.

Getting started

1. Obtain permission to process the media.
2. Supply a direct HTTP or HTTPS download URL in Direct media URLs.
3. Optionally lower Maximum files.
4. Run the Actor and inspect each dataset row's status.
5. Download successful downloadUrl artifacts and send them to your ASR system.

The prefilled public JFK sample is an 11-second WAV from the whisper.cpp sample collection. A successful run produces one WAV artifact and its metadata.

Input parameters

Parameter	Default	Meaning
mediaUrls	Required	1–10 direct public HTTP(S) audio/video file URL strings.
maxItems	10	Process the first 1–10 unique supplied URLs globally per run, counting failures.

{
  "mediaUrls": ["https://raw.githubusercontent.com/ggerganov/whisper.cpp/master/samples/jfk.wav"],
  "maxItems": 10
}

Exact duplicate URL strings are removed before applying the limit. Different query strings remain separate requests. There is no search, pagination, automatic source discovery or proxy setting.

Supported files and limits

Supported containers include WAV, MP3, MP4/MOV/M4A, Ogg, FLAC, Matroska/WebM and AAC, subject to FFmpeg decoder support. Encrypted or DRM-protected files are not supported. Inputs must have an audio stream and a known positive duration.

• Maximum downloaded file: 25 MiB.
• Maximum duration: 600 seconds per file.
• Download deadline: 30 seconds, including redirects after DNS resolution.
• At most three redirects; every destination is validated and pinned to a public address.
• Probe deadline: 10 seconds; conversion deadline: 30 seconds.
• Shared processing budget: 60 seconds per run, including downloads, probes and conversion. Remaining files receive error rows once exhausted. Storage/API overhead is additional; platform timeout is 120 seconds.
• Files run sequentially. Large or slow files can fail within these deadlines.
• Only HTTP(S) and ports 80/443; no URL credentials, cookies or custom authentication headers.

Public signed file URLs can work while valid. Query strings and fragments are omitted from dataset source URLs. Pages, HLS/DASH playlists, private networks and localhost destinations are rejected. FFmpeg receives a local downloaded file and cannot fetch remote playlists.

Output fields

One dataset row is returned for each attempted unique URL.

Field	Meaning
status	success or error.
inputIndex	One-based index after deduplication.
sourceUrl	Supplied URL without query or fragment.
sourceBytes	Downloaded source byte count, on success.
sourceAudio	Source codec, sample rate, channels and duration.
durationSeconds	Verified WAV duration.
sampleRate, channels	Always 16000 and 1 on success.
codec, format	Always pcm_s16le and wav on success.
outputBytes, sha256	Artifact size and byte checksum.
storageKey, downloadUrl	Run storage key and artifact link.
processedAt	Completion time in ISO format.
error	Safe failure explanation, only on error rows.

Example result

For the prefilled 11-second speech sample, the local output included:

{
  "status": "success",
  "inputIndex": 1,
  "sourceBytes": 352078,
  "durationSeconds": 11,
  "sampleRate": 16000,
  "channels": 1,
  "codec": "pcm_s16le",
  "format": "wav",
  "outputBytes": 352078,
  "sha256": "49e623d8aad1f7b1ed0ad3891315bb2c8db9c49c7f0c5de454bb5d1180a11614",
  "storageKey": "audio-1.wav"
}

Cloud rows also contain an Apify storage download URL. Local runs return a local file URL. Error rows omit artifact and encoding fields.

How much does it cost to extract mono speech audio?

Pay-per-event pricing includes a $0.005 start fee and a successful-file event. Failed files have no item event charge. A run with no successful files fails, but its valid start event remains chargeable. Budget limits can stop a batch; inspect partial results rather than assuming it completed. Give the maximum-charge budget a little headroom above the displayed estimate to avoid SDK floating-point boundary rounding.

Apify tier	Per successful file
FREE	$0.0092
BRONZE	$0.008
SILVER	$0.00624
GOLD	$0.0048
PLATINUM	$0.0048
DIAMOND	$0.0048

At BRONZE, one successful file costs $0.013, five cost $0.045, and ten cost $0.085 including one start fee. Your Apify plan and storage retention terms still apply. Download your files before run storage expires.

Failure behavior and troubleshooting

A mixed batch succeeds when at least one artifact succeeds and includes error rows for failed files. If all files fail, the run fails after saving the error rows. Malformed batch input fails before start billing.

A web-page URL failed. Supply the actual media file URL, not a player, social post or login page.

The file downloaded but did not convert. Check that it has an audio stream, a supported codec, a known duration no longer than ten minutes and no DRM. Corrupt media and files requiring remote dependencies are rejected.

The download timed out. Use a fast, anonymously accessible file host. The Actor does not bypass origin access controls or retry with paid proxies.

Integrations

Use Apify schedules to process a supplied batch regularly. Consume dataset metadata with Make, Zapier or your own webhook receiver. Download WAV files outside the automation's text payload and send them to your authorized ASR service. Keep checksums alongside job IDs to verify artifacts and avoid redundant downstream transcription.

API usage

Start a run and retain its run ID:

curl -X POST 'https://api.apify.com/v2/acts/automation-lab~direct-media-mono-speech-audio-export/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" -H 'Content-Type: application/json' \
  -d '{"mediaUrls":["https://raw.githubusercontent.com/ggerganov/whisper.cpp/master/samples/jfk.wav"]}'

With JavaScript:

import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/direct-media-mono-speech-audio-export').call({ mediaUrls: urls });
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 10 });

With Python:

import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/direct-media-mono-speech-audio-export').call(run_input={'mediaUrls': urls})
items = client.dataset(run['defaultDatasetId']).list_items(limit=10).items

Download successful artifact links separately; the dataset contains metadata, not embedded audio.

MCP usage

Use the scoped Actor endpoint:

claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/direct-media-mono-speech-audio-export'

{"mcpServers":{"apify":{"type":"http","url":"https://mcp.apify.com?tools=automation-lab/direct-media-mono-speech-audio-export"}}}

For Claude Desktop, Cursor, and VS Code, use the equivalent HTTP server configuration above (subject to client support).

Authorize the client, then discover actual names and schemas with tools/list. The scoped endpoint also includes run and storage tools; it does not expose exactly one tool.

Example prompt: “Convert these authorized direct file URLs to mono WAV audio, then return encoding metadata and download links.”

Start once and retain the returned run ID, status and storage IDs; these are metadata, not result rows. call-actor waits at most waitSecs (0–45 seconds, default 30), so a start call may return before completion. Set the client request timeout above the selected server wait plus transport margin, within a 120-second total consumer deadline. For a nonterminal status, use get-actor-run for the same run with bounded 2/4/8-second backoff, capped at ten seconds. On client timeout, recover the known run rather than restarting it. If its ID is unknown, report uncertainty instead of blindly rerunning. At the deadline, report pending with the run ID and stop polling.

After success, use get-dataset-items with the returned defaultDatasetId, explicit limit: 20, offset: 0, and needed fields in the format from the discovered tool schema. For example, select status, inputIndex, sourceUrl, sourceAudio, durationSeconds, sampleRate, channels, codec, format, sha256, downloadUrl and error. Prefer untransformed JSON. Advance the source offset using pagination metadata or source rows consumed, not transformed/filtered row counts. Stop at exhaustion or a total budget of 100 source rows and 64 KiB of serialized UTF-8 content admitted to model context, whichever comes first. These are consumer context limits, not Actor collection limits.

Report terminal failures (FAILED, TIMED-OUT, ABORTED) honestly. Any available dataset rows are partial results, not a successful full batch. Even on a successful mixed batch, inspect each row's status and disclose file errors or budget-stopped processing.

Process each page host-side before model injection. Enforce the byte ceiling even for an oversized row/page: omit or summarize it with disclosure. Report returned row count, any partial/truncated status and the source continuation offset; never silently claim completeness. Keep WAV downloads and full exports outside model context. If your client cannot intercept oversized responses, do not claim a hard byte guarantee or request unbounded results. Discovery or caching alone does not guarantee token savings.

Legality, privacy and responsible use

Process only recordings you own or are authorized to use. No transcripts are generated, and audio is not sent to a third-party speech API. Working media files are removed after each input; output WAV artifacts remain in your Apify run storage until deleted or expired. Artifact links follow Apify storage permissions: treat links as sensitive and avoid processing confidential recordings without an appropriate retention/access policy.

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; reports are retained for 30 days. Input itself remains governed by Apify run storage; avoid sharing signed URLs or private recordings publicly.

FAQ

Can it extract from YouTube or TikTok pages? No. Resolve your authorized direct media URL separately.

Can it return MP3, Opus or text? No. This version returns only 16 kHz mono PCM WAV, with no transcripts.

Is stereo preserved? No. Channels are downmixed to one mono channel for speech preprocessing.

Are silence and background noise removed? No. Content and timing are preserved apart from audio resampling and channel mixing.

Related Actors

For a separate transcription workflow, see Audio Speech-to-Text Transcriber. To discover archival file metadata before selecting authorized downloads, see Internet Archive Search & Item Metadata.

Support

Report reproducible failures through the Actor Store Issues tab with a run link and non-sensitive input. This utility is independently operated; no third-party endorsement is implied. Runtime uses FFmpeg locally and Apify storage; there is no paid speech provider.