Live Stream Transcript

Independent live-media processing Actor. Live Stream Transcript is not affiliated with, endorsed by, or operated by YouTube, TikTok, Twitch, their owners, or broadcasters. Source detection, media access, recording, speech recognition, and output availability can change without notice.

Live Stream Transcript accepts one public live-page URL and attempts to record media in approximately 60-second MP4 segments. For each accepted segment it charges 60 seconds events before transcription, uploads the segment to the run key-value store, and writes one source-dependent Dataset row with available stream metadata and speech-recognition fields.

• A current YouTube URL was independently confirmed as is_live=true, and the Actor observed its title, author, and changing viewer count.
• That 300-second cloud test produced no media file, no Dataset row, and zero seconds events before timing out.
• An earlier 179-second run also finished with zero rows and zero seconds events.
• A successful row can expose up to 18 top-level keys, but language, text, and phrase segments can be absent if transcription fails.

This is a best-effort capture and transcription workflow, not a guaranteed real-time feed. Extractor metadata detection does not prove that FFmpeg can record the media. Bound every run with timeout and charge controls, inspect Dataset and KVS results, and confirm content rights before retaining or using a broadcast.

Open the live-stream input · Integrate through the Apify API

Why Choose This API

Live media processing has several independent failure points. A page extractor must recognize the URL, a playable media URL must remain valid, FFmpeg must write a stable segment, the billing manager must accept a 60-second charge, the speech model must process the audio, and the MP4 upload and Dataset write must finish. This Actor coordinates that sequence and provides Apify run, storage, and event records around it.

The output is segment-oriented rather than one continuously updated transcript. The recorder targets approximately 60-second files. A file is considered for processing only after its modification time has remained unchanged for more than another segment interval. As a result, the first Dataset row cannot be expected after exactly 60 seconds, and startup, source behavior, model loading, storage, or retries can extend latency substantially.

Each accepted segment is charged before transcription. A charge shortfall stops segment processing. If transcription raises an exception, the row can still contain source metadata and a stored recording URL while omitting language, text, and segments. Consumers must validate those keys rather than assuming every billed capture yields usable speech text.

The Actor has no input for duration or segment count. It continues until the stream appears ended, repeated capture attempts produce no usable files, a billing cap stops the next segment, the run reaches its timeout, or the user aborts it. Use Apify run options as explicit production controls.

Quick Start Guide

Choose a public URL that is actively live at run time. A page that was live when this README was updated may later end, become private, redirect, or change media format. Start with a bounded diagnostic run.

{
  "live_url": "https://www.youtube.com/watch?v=LuKwFajn37U"
}

Set the run timeout to at least several minutes if you expect a segment, because recording plus the stability wait already exceeds the nominal 60-second segment length. Also set a maximum-total-charge value that can cover four memory-based Actor Start events at the 4096 MB default, Actor Usage, and at least one 60-second capture batch. A cap that cannot admit the next full batch produces no partial segment.

Start the Actor and monitor logs. Metadata lines showing title, author, viewers, or is_live confirm only source discovery. Look for non-zero recorded megabytes, a seconds charge, a Dataset item, and a KVS MP4 before treating the run as a capture success.

After termination, record the run ID, build, source URL, timeout, charge cap, status, logs, charged-event counts, Dataset count, KVS keys, and any transcript keys. Do not retry an inaccessible source indefinitely.

Input Parameters

Parameter	Type	Required	Format	Behavior
live_url	string	Yes	Public http:// or https:// page URL	Sent to the current media extractor. TikTok URLs are normalized to the account's /live path; other URLs are passed through.

The Actor does not expose duration, segment size, language, model, translation, platform, quality, output format, retry count, or maximum-segment inputs. The segment target is fixed at 60 seconds in the current runtime, and the speech model selects language automatically when transcription starts.

URL validation confirms only that the value is a non-empty HTTP(S) string. It cannot prove that the stream is live, public, supported by the extractor, recordable by FFmpeg, audible, or legally reusable. Validate those conditions independently.

Use the Apify timeout to limit wall-clock runtime and a maximum-total-charge setting to limit event charges. These controls can stop work before any row is produced; neither guarantees a complete transcript.

Output Data Schema

A processed segment can contain up to 18 top-level keys:

Group	Possible fields	Important boundary
Run provenance	processor, processed_at	Actor URL and a timestamp initialized for the run, not necessarily the exact segment end time.
Source identity	platform, title, description, author, author_id	Extractor values; missing values can be represented as empty strings.
Source state	start_time, verified, follower_count, like_count, view_count, avatar, is_live	Dynamic snapshots; false or zero can mean unavailable rather than a confirmed fact.
Stored media	record_url	Public URL for the uploaded MP4 segment, or an empty string if upload fails.
Speech recognition	language, text, segments	Can be omitted when transcription fails; language can be wrong and text can be empty.

The following is a schema illustration, not a live result from the zero-row baseline. Placeholder values show the intended shape only.

{
  "processor": "https://apify.com/agentx/live-stream-transcript?fpr=aiagentapi",
  "processed_at": "2026-07-23T22:36:53+00:00",
  "platform": "Youtube",
  "title": "<source title when available>",
  "description": "<source description or empty string>",
  "author": "<source uploader>",
  "author_id": "<source uploader id>",
  "start_time": null,
  "verified": false,
  "follower_count": 0,
  "like_count": 0,
  "view_count": 0,
  "avatar": "<source thumbnail url>",
  "record_url": "<public KVS MP4 url>",
  "is_live": true,
  "language": "English",
  "text": "<transcript for this segment>",
  "segments": [{"start": "15:42:01.000", "end": "15:42:05.000", "text": "<phrase>"}]
}

Phrase labels combine the recording filename's clock-derived value with speech-model offsets. Do not assume they are precise elapsed-from-stream-start timestamps. If exact synchronization matters, retain the MP4, source timestamps, and independent timing evidence.

Integration Examples

The stable Actor ID is TAdj0O8jUfCBxuS45, and the full name is agentx/live-stream-transcript. API clients should start it asynchronously, poll the run, and inspect both the default Dataset and key-value store. A synchronous request window is usually too short for recording, stabilization, transcription, and upload.

MCP clients should fetch Actor details before calling. This bounded example allows more time than the observed 300-second zero-row diagnostic:

{
  "actor": "agentx/live-stream-transcript",
  "input": {
    "live_url": "https://www.youtube.com/watch?v=LuKwFajn37U"
  },
  "callOptions": {
    "memory": 4096,
    "timeout": 600,
    "maxTotalChargeUsd": 0.5
  },
  "waitSecs": 45
}

A 45-second MCP response will normally show a still-running capture. Poll the returned run ID instead of starting duplicates. If the run is no longer useful, abort it rather than waiting for an open-ended source. After termination, fetch Dataset items and KVS records independently.

Do not interpret metadata-only logs as output. Require the evidence appropriate for your workflow: non-zero seconds, one or more rows, stored MP4 URLs, and non-empty transcription fields.

Pricing & Cost Calculator

The Actor uses pay-per-event pricing. Seconds are requested in fixed batches of 60 before a captured segment is transcribed. Console pricing and actual charged events are authoritative.

Event	Trigger	Free	Bronze	Silver	Gold	Platinum	Diamond
Actor Usage	Runtime, proxy, model work, and storage consumption	$0.00001 per usage unit	same	same	same	same	same
Actor Start	Actor starts; counted events depend on memory	$0.01	same	same	same	same	same
Seconds	Each accepted second in a 60-second capture batch	$0.00369	$0.00357	$0.00344	$0.00332	$0.00332	$0.00332

One 60-second batch contributes $0.22140 at Free, $0.21420 at Bronze, $0.20640 at Silver, or $0.19920 at Gold and above, before Start and Usage. The 4096 MB baseline recorded four Actor Start events, so at the current local Start price that part contributes $0.04.

No seconds were charged in the two verified zero-output baselines because no stable file reached push_limit. Runtime can still incur Start and Usage. A timed-out process may also terminate before the runtime records its normal end-of-run Usage event, so compare the platform bill with the event snapshot.

A maximum charge below the next full 60-second batch and other events can stop before output. Charges represent accepted capture seconds, not a promise of correct language, non-empty text, or complete transcription.

Use Cases & Applications

Media teams can attempt bounded capture of a public broadcast they are permitted to retain, then review the stored MP4 and transcript together. The output is better suited to post-segment processing than to low-latency captions.

Researchers can create timestamped observations of public events, subject to source rights and retention rules. A zero-row run is a meaningful operational outcome and should be preserved rather than replaced with a guessed transcript.

Monitoring systems can send successful segment text to classifiers or alert queues. They should require non-empty text, preserve the source and run IDs, and use human review for moderation or consequential escalation.

Content teams can use successful transcripts as drafts for summaries or social posts. Speech recognition can mishear names, numbers, accents, overlapping speakers, music, or poor audio. Review against the stored recording before publication.

Accessibility workflows should not treat this Actor as a certified captioning system. Latency, missing segments, recognition errors, and clock-derived phrase labels require separate quality assurance.

FAQ

Is this real-time streaming transcription?

No. The current implementation processes approximately 60-second media files after a stability wait, so output is delayed and segment-based.

Why can a live URL return zero rows?

The extractor may detect metadata while FFmpeg fails to write a usable file. The stream can also end, restrict media, change format, or exceed the run timeout.

Does one row contain the complete broadcast?

No. A row represents one processed media segment. Multiple successful segments produce multiple rows.

Are transcript fields always present?

No. If speech recognition fails, the row can omit language, text, and segments.

Why are seconds charged before text exists?

The runtime requests the 60-second capture charge before transcription and storage. A charged segment is not a transcription guarantee.

How do I stop an ongoing live run?

Use a finite run timeout, a maximum-total-charge limit, or abort the run through Apify. There is no duration input field.

Trust & Certifications

The readiness baseline used the public Build with 4096 MB memory. A current YouTube source was independently detected as live, but a 300-second run wrote no MP4 and timed out with zero Dataset items and zero seconds. An earlier 179-second run also returned zero rows. These results verify failure handling, not successful platform coverage.

No platform count, source coverage, transcript accuracy, latency, completeness, uptime, accessibility, copyright clearance, privacy compliance, or third-party certification is claimed. Extractor, FFmpeg, speech model, source, network, and Apify behavior can fail independently.

Production users should monitor run status, logs, recorded megabytes, event counts, Dataset count, KVS keys, stored file size, transcript key presence, language, text length, segment timing, and repeated source failures. Retain only what your purpose and policy require.

Legal & Compliance

Use this Actor only for streams, purposes, and volumes permitted by applicable law, contracts, platform rules, broadcaster terms, and content licenses. A publicly reachable broadcast is not automatically licensed for recording, redistribution, training, surveillance, or commercial reuse.

You are responsible for copyright, neighboring rights, privacy, voice and likeness rights, consent, notices, retention, access control, cross-border transfers, and downstream decisions. Live speech can contain personal, confidential, defamatory, violent, or otherwise sensitive material. Apply appropriate review and safeguards.

Review the Apify General Terms and Conditions, Actor Terms, and Privacy Policy, plus the terms of every source platform and broadcaster. These links and statements are informational, not legal advice.

Related Tools

For multi-platform video discovery, use All Video Scraper. For an already recorded media URL, compare Video Transcript. To retrieve existing caption tracks rather than record live audio, use Video Captions Downloader.

Turn a reviewed transcript into draft content with Video to Social Post, add channel-level context with YouTube Market Intelligence, or use TikTok Live Downloader for its separate TikTok-specific recording contract.

Support & Community

For a reproducible issue, provide the run ID, build, public live URL, timeout, charge cap, terminal status, last relevant log lines, charged-event counts, Dataset count, KVS key count, and recorded file size when present. State whether metadata was detected and whether recorded megabytes ever exceeded zero.

Never send an Apify token, proxy credential, private stream URL, account cookie, confidential recording, or unrelated personal information. Redact transcript material unless it is necessary and permitted for support.

Use AgentX support on Telegram for Actor-specific help and the Apify community for platform questions.

Last updated: July 23, 2026.