editing_add_lower_third
ChatGPTAdds one lower-third text clip for a person's name plus an optional role/title. The caller supplies the first-appearance time; this tool does not detect speakers or load the transcript. The built-in speaker style is used unless explicit overrides are supplied. Use add_text_overlay for generic title, subtitle, body, or speaker text. This tool does not automatically apply brand lower-third styling because no supported brand text-style contract exists.
editing_add_text_overlay
ChatGPTAdds a built-in 16:9 editor text style (title, subtitle, body, or speaker label) to an edit. This is the recommended way to add text using the standard Text panel presets. Use batch with insert_text_overlay only for advanced gradients, custom animations, or explicit low-level layering. Pass expectedRevision from your last read.
editing_apply_brand
ChatGPTFetch a studio's brand kit and apply it to an edit's timeline. Atomic — all areas apply together or the edit is left untouched. Returns which brand areas were applied and which were skipped (with reasons). Applies Logo, Design (spacing/radius + solid or image background), Captions, and Intro/Outro media. May be feature-gated; a disabled call returns a feature-disabled error - surface it to the user, don't retry.
editing_apply_smart_layout
ChatGPTAutomatically generates scenes with optimal layouts based on speaker activity. This is the recommended way to apply smart layouts (instead of batch with apply_smart_layouts). Pick a style: Smart (active speaker + auto grid shots + camera-switch breaks), FullScreen (active speaker only), PictureInPicture (large speaker + small overlays), SplitScreen (equal split), or Grid (static grid, no switching). Advanced autoGridShotSettings / enhancedCameraSwitching overrides apply only to style: "Smart"; their defaults are tuned for a natural rhythm — only override on explicit request. All time fields are integer milliseconds. Pass expectedRevision from your last read.
editing_apply_smart_mutes
ChatGPTAutomatically mutes non-speaking segments across the edit using AI detection. This is the recommended way to apply smart mutes (instead of batch with apply_smart_mutes). Pass expectedRevision from your last read. Use restore_audio_cleanup with cleanup="smart_mutes" to remove the mutes it created. Fails with FAILED_PRECONDITION when the edit has no loadable transcript (speech detection requires it); context.reason says why.
editing_apply_verified_edit_plan
ChatGPTSafest single-call path for a complex raw editing batch: validates, applies, and verifies the revision-bound plan after one preparation pass. Use standalone high-level write tools for simple common operations. Use validate_edit_plan followed by batch only when a separately inspectable preflight is required.
editing_batch
ChatGPTApplies a batch of editing operations atomically. All succeed or all roll back. Input: { editId: string, operations: [{ type, params }] } Call get_editing_guide with section="operations" for per-operation parameters. Call get_editing_guide with section="usage" for time format, ordering, examples, and error recovery. Use set_visual_crop for one static normalized crop from a clip or track's first visible frame. Keep modify_crop for advanced or time-varying crops. Use set_color_correction for one static color-correction patch on a clip or track; keep modify_color_correction for advanced or time-varying color keyframes. For complex or multi-operation batches, optionally call validate_edit_plan immediately before this tool with exactly the same payload, then pass its planHash as validatedPlanHash. Do not preflight standalone write tools. Available categories: clip, cut, synced-cut, mute, track, scene, chapter, visual-transform, animation, caption-settings, layout, overlay, transcript, magic-audio, brand, aspect-ratio. Use get_editing_guide before composing destructive batches.
editing_clone_edit
ChatGPTCreates a new edit with a complete copy of the source edit's saved timeline. The original edit is not modified. Returns the new edit ID, the revision as a string (usable directly as expectedRevision), and sessionId. The returned editId becomes the working edit for this flow. Use it for subsequent edits instead of creating another copy, unless the user explicitly asks for a separate version.
editing_compare_revisions
ChatGPTDiff two timeline revisions. Returns { navigable: { created, modified, deleted }, toggles, propertyChanges, durationBeforeMs, durationAfterMs }. navigable holds positionally addressable entity diffs (clips, scenes, cuts, mutes) with aligned playback positions in ms. Each cut/mute carries a feature field identifying which AI feature produced it ('removeFillerWords' | 'removePauses' | 'smartMute') or null for user/manual edits. Timeline-level synced cuts are included as cut entities. durationBeforeMs/durationAfterMs are effective durations (source minus synced-cut durations), so they reflect synced-cut changes. toggles lists one entry per AI-feature toggle whose enabled state changed between the two revisions (removeFillerWords / removePauses / smartMute / magicAudio). propertyChanges lists keyframe-based property changes that are not navigable entities — currently volume: one entry per changed audio.volume keyframe (on a track or clip) with the dB/multiplier level before and after. Use after an agent run to summarize what changed. Diff positions are milliseconds, unlike {n,d} reads. Revisions are canonical non-negative integer strings. The response identifies both snapshots and the current head observed after reading them; this metadata is observed, not transactional.
editing_create_edit_from_recording
ChatGPTCreates a new editable timeline from a recording session. The original recording is not modified. Returns an editId to use with transcript, timeline, and editing tools. The returned editId becomes the working edit for this flow. Use it for subsequent edits instead of creating another copy, unless the user explicitly asks for a separate version. This capability may be unavailable for the current Riverside account. If it returns FAILED_PRECONDITION, retrying will not help until availability changes; use an existing editId from platform_list_edits, or ask the user to open or create an edit in Riverside.
editing_cut_time_ranges
ChatGPTCreates cuts across all recording tracks for the given time ranges. Accepts integer times in milliseconds as startMs/endMs; do not pass {n,d} fractions. The server handles fraction conversion and reverse-chronological ordering internally. For transcript-derived cuts, call resolve_transcript_selection with intent="remove" to cut the selection, or intent="keep" to cut everything outside it, and execute the resolver response's payload.input unchanged once readyToApply is true. Callers should use source="user" for agent-proposed and exact user-specified cuts. The "director" enum value remains only for backward compatibility with existing stored provenance. This is the recommended way to create cuts (instead of batch with create_cuts_from_collapsed_range).
editing_get_asset_metadata
ChatGPTReturns name, type, duration, and resolution for a media asset by its ID. Use duration to choose overlay length for video/audio assets; duration is null for images. Resolution is returned as { width, height } in pixels. The dedicated insert_overlay tool resolves dimensions server-side; do not pass resolution to that tool. When calling batch insert_overlay directly, batch insert_overlay still requires resolution from get_asset_metadata for image/video overlays; omit it only for audio. For images without a stored resolution the dimensions are measured live from the file. Also returns externalSource (asset provenance — e.g. "hyperframes" for a rendered HyperFrame overlay or "pexels" for stock; null for user uploads) and externalSourceId. Fails with FAILED_PRECONDITION only when the resolution cannot be determined at all.
editing_get_brand
ChatGPTFetch a studio/production brand kit (logo, colors, design, captions, intro/outro). Read-only — does not modify the kit or any edit.
editing_get_captions_presets
ChatGPTFetch the full pool of captions style presets available to a studio. Returns three fields. (1) brandCaptionsList — the brand-kit caption styles; THIS is the brand source of truth. To apply the brand style, pick the entry with isDefault=true, or the lowest sortOrder if none is marked. (2) brandCaptions — the SAME brand styles in the legacy per-ratio format. It is NOT an additional pool and may duplicate brandCaptionsList; read it ONLY when brandCaptionsList is empty (kit not yet migrated). Never merge or count the two lists together. (3) presets — the general catalog: studio-saved custom presets first (isBuiltIn=false), then built-in defaults (isBuiltIn=true); use these when not applying the brand. Always pick an existing preset style instead of inventing caption styling. Read-only — does not modify the kit, presets, or any edit.
editing_get_editing_guide
ChatGPTReturns editorial strategy, multi-pass review, and cut rationale guidance, plus operation params, time conversion, transcript/timeline workflows, and error recovery.
editing_get_export_publish_data
ChatGPTBefore publishing to YouTube, returns any Content-ID/copyright codes for the edit's media. A non-null youtubeCode flags a potential copyright match.
editing_get_layout
ChatGPTReturns the full layout plan for a single layout id, including undescribed layouts. layoutPlan is a large opaque blob; list_layouts' summary usually suffices.
editing_get_revision
ChatGPTReturns the current revision identifier for an edit without fetching the full timeline or transcript. Use this to cheaply verify that a cached revision is still current before issuing other tool calls. The returned revision matches the value reported by read_aligned_transcript, batch, and cut_time_ranges. Pass the returned value directly as expectedRevision on revision-aware writes.
editing_get_stock_media
ChatGPTSearches the stock library (Pexels) for images or videos matching a natural-language query and returns a list of options to choose from — it does NOT modify the timeline. Call this first when the user asks for a stock photo or clip (e.g. "add a photo of a city skyline"), review the results, then call insert_stock_media with the chosen option's externalSourceId. Returns an empty list if nothing matches. Each option also carries the Pexels url (its path is descriptive) and tags (often empty). description is the library alt text: present for images, null for videos — so for videos lean on the url and the query.
editing_get_stock_music
ChatGPTBrowses the FREE built-in music library (the editor’s "ready-made collections") and returns tracks to choose from — it does NOT modify the timeline, and it is free for all users. Call this first when the user wants background music (e.g. "add an intro jingle for an education video"), then place the chosen track with insert_audio: pass the track's mediaId as assetId (durationMs defaults to the full track; volume/fades optional). Tracks are organized by COLLECTION (content genre) and SECTION (where it plays); within each, pick a variant by name — High/Low = intensity, Short/Long = length. Collections: lifestyle, newsPolitics, educational, gaming, artsEntertainment, businessTech, trueCrime, sportsRecreation. Sections: intro, outro, transition, underscore. (This is the free library; the larger paid library is separate.)
editing_insert_audio
ChatGPTInserts an AUDIO asset (music track, sound effect, voiceover, uploaded audio) onto the timeline as an audio layer, with optional volume and fade-in/fade-out — the audio-specific controls image/video overlays do not have. This is how a built-in music track from get_stock_music is placed: pass its mediaId as assetId (durationMs defaults to the asset's full length). For image/video assets use insert_overlay instead.
editing_insert_media_as_scene
ChatGPTInserts an existing IMAGE or VIDEO media asset as a new FULLSCREEN scene at a timestamp. Unlike insert_overlay, which layers a clip on top of existing content without changing length, this GROWS the timeline: it adds a whole scene, increasing total duration and rippling all later content to the right. Use insert_overlay for layered/PiP or lower-third placement that leaves duration unchanged; for AUDIO (music, sound effects, voiceovers) use insert_audio. Returns BAD_REQUEST if startMs is outside the current playable timeline (past the end, or inside a removed/cut region), and requires durationMs when inserting a video whose media duration is unknown.
editing_insert_overlay
ChatGPTInserts a VISUAL media asset (image or video) as a timeline overlay, placed on top of existing content. Resolves the asset type and pixel dimensions server-side — pass just the assetId and timing. This is the recommended way to insert uploaded images/videos as an overlay (instead of batch with insert_overlay, which requires the caller to supply resolution). For AUDIO assets (music, sound effects, voiceovers) use insert_audio instead, which adds volume and fade controls. To place an image/video as a NEW FULLSCREEN scene that GROWS the timeline (shifting later content right) instead of layering on top, use insert_media_as_scene. Fails with FAILED_PRECONDITION if the asset's dimensions cannot be determined.
editing_insert_stock_media
ChatGPTInserts a chosen stock-library item (from get_stock_media) onto the timeline as an overlay: it imports the item into the project media, then places it — all server-side. First call get_stock_media to search and pick an option, then call this with that option's externalSourceId and matching mediaType. Returns NOT_FOUND if the chosen item no longer resolves.
editing_list_edit_recording_asset_sessions
ChatGPTGiven an editId, returns the recording sessionId(s) behind its clips; feed these to platform_get_transcript or search_riverside. Throws if any source is unresolvable.
editing_list_layouts
ChatGPTLists described layout templates in bounded pages, sorted by id. Only layouts with a textDescription are included. Filters use explicit backend metadata only: aspect ratio, match criteria, and true capability attributes; no ids or prose are inferred. Use to discover available layouts before applying one with batch/change_layout.
editing_read_aligned_transcript
ChatGPTDefaults to compact rows in the sentences response field. Rows are returned in chronological order on one global playable timeline shared by every speaker. Rows may overlap when speakers interrupt or talk over one another. In detail="words" without a window, playable rows sort by first playable word start, then end; deleted/unplayable word-detail rows sort last. Bounded word reads omit words without positive-duration overlap with the requested half-open window. Compact sentence mode omits rows with no playable words. Rounding rules apply only to *Ms fields: playableStartMs uses floor and playableEndMs uses ceil; {n, d} fields are unchanged. In word mode, assetStart/assetEnd/playableStart/playableEnd are {n, d} fractions of seconds. Rows are acoustic segments, not a grammatical sentence; use them for locating, never as final cut points. startsMidSentence/endsMidSentence mark continuations; extend kept spans past flagged rows. For cut-grade timestamps, request detail="words" with startMs/endMs and use the intended phrase's true first and last word; see get_editing_guide. Treat word-mode output as working data; report only selected ranges with short evidence snippets. Rows and words include opaque edit/revision-scoped spanIds/wordIds; pass them to resolve_transcript_selection, not reconstructed timestamps. Word-mode word clipId values are opaque strings; keep them round-trippable. Use playable timestamps for the edited timeline; do not substitute asset/source timestamps. For transcript edits, pass spanId/wordId and explicit intent to resolve_transcript_selection; execute payload.input only when readyToApply is true, never when payload is null. Word mode clips to the half-open window and returns bounded wordDetail metadata; maxWords/maxBytes defaults and caps are in their schemas. Pass the returned revision as expectedRevision only to write tools whose input schema exposes that field. See get_editing_guide for the full revision-safe workflow.
editing_read_timeline_in_range
ChatGPTReturns a filtered view of the timeline data scoped to a requested time range. This is the primary read API for agents to understand what exists at a given point in the timeline — which tracks, clips, scenes, layouts, keyframes, and transforms are active in that window. The response is a self-contained cut of the full timeline, scoped to the requested range. All time values in the response (trackTime, timeRange, duration, scene times) are {n, d} fractions of seconds (time = n/d). Pass them directly to fraction-based batch operation params. For source-time millisecond tools such as reorder_timeline and insert_overlay, convert first with Math.round(1000 * n / d). cut_time_ranges.startMs/endMs, insert_audio.startMs, and add_lower_third/add_text_overlay startMs/durationMs are playable time; do not pass raw source timestamps because each tool converts playable placement back to source time. All returned times are source time, not the effective/playable (post-cut) axis — once cuts exist, do not compare them 1:1 against playableStartMs/playableEndMs from read_aligned_transcript. On each clip, trackTime is its position on the timeline and timeRange.start is the in-point into its source asset. Structural details — where clip/track uniqueIds live, and collapsed-clip detection by matching trackTime+timeRange across tracks — are in get_editing_guide section "usage".
editing_remove_fillers
ChatGPTRemoves transcript-labeled disfluency regions across the edit: filler words, noise, and word-level disfluencies. Classification comes from the transcript; this tool does not analyze audio. method chooses how: "Cut" deletes eligible regions when safe, "Mute" silences them while preserving timing, and "Smart" is duration-based, not content-adaptive: it mutes eligible regions shorter than 500 ms and cuts regions 500 ms or longer when safe; crosstalk is muted. This is the recommended way to remove transcript-labeled disfluencies (instead of batch with remove_fillers). Pass expectedRevision from your last read. Use restore_audio_cleanup with cleanup="fillers" to undo the remove_fillers cleanup (batch restore_fillers is the low-level fallback). Fails with FAILED_PRECONDITION when the edit has no loadable transcript (filler detection requires it); context.reason says why.
editing_remove_pauses
ChatGPTRemoves silent pauses longer than thresholdMs across the edit by creating cuts. This is the recommended way to remove pauses (instead of batch with remove_pauses). Accepts integer milliseconds. Each shortened pause keeps thresholdMs / 2 of silence. thresholdMs: 0 matches the editor's "Super fast" pace: every pause is shortened to a fixed 150 ms gap. Pass expectedRevision from your last read. Use restore_audio_cleanup with cleanup="pauses" to restore removed pauses (batch restore_pauses is the low-level fallback). Fails with FAILED_PRECONDITION when the edit has no loadable transcript (pause detection requires it); context.reason says why.
editing_resolve_transcript_selection
ChatGPTResolves transcript word, span, exact-text, boundary-to-boundary, or playable-time selections into edit-safe playable millisecond ranges. Prefer boundary_range for a contiguous quote-to-quote selection: it accepts inclusive start and end word, span, or text anchors, then uses the first playable start and final playable end without manual fraction conversion. Text anchors use NFKC-normalized, case-insensitive matching that ignores surrounding punctuation but preserves internal apostrophes; use 1-based occurrence when a quote repeats. Transcript handles are scoped to one edit and revision; returned integer endpoints never exceed the timeline. Intent is required. remove returns only a cut_time_ranges payload with sorted and merged cuts of the selection; keep returns a cut_time_ranges payload that cuts everything outside the selection, so the kept ranges stay in place in chronological order; generated cut inputs use source="user" because they are user-directed edits. The move intent requires reorder_timeline availability. When reorder_timeline is unavailable, move is rejected because this restriction prevents duplicate tracks from permanently inflating the edit; retrying will not help until availability changes — use keep or remove, or batch for individual clips. Unresolved warnings fail closed with payload=null. It never mutates the edit. A selection list of only time_range entries stays available even while transcript alignment is paused.
editing_restore_audio_cleanup
ChatGPTUndoes an audio-cleanup effect previously applied by the corresponding standalone or batch cleanup operation. Choose cleanup: - "pauses" — restores pauses removed by remove_pauses or shortened by shorten_pauses (undoes those cuts) - "fillers" — restores filler words removed by remove_fillers (undoes those cuts/mutes) - "smart_mutes" — removes the mutes created by apply_smart_mutes This is the recommended way to undo audio cleanup (instead of batch with restore_pauses / restore_fillers / remove_smart_mutes). Pass expectedRevision from your last read. Fails with FAILED_PRECONDITION when the edit has no loadable transcript (these operations need the recording transcript, even to undo); context.reason says why.
editing_set_brand
ChatGPTUpdate a studio's brand kit. Partial patch — only the provided fields change; everything else in the kit is preserved. Asset fields reference existing media by ID (uploading new media is out of scope). Does not modify any edit. May be feature-gated; a disabled call returns a feature-disabled error - surface it to the user, don't retry.
editing_set_captions
ChatGPTSets the edit’s global caption settings (show/hide, position, and style). This is the recommended captions write path (instead of batch with update_global_caption_settings); it hides the raw captionsJson string and the set_captions_visibility init-first prerequisite — show is written into the global settings, so no separate visibility call is needed. Only the fields you pass are changed: they are merged onto the current caption settings, so omitted fields (and style sub-fields) are preserved. Use get_captions_presets to discover an exact preset ID, then pass that presetId with the studioId returned by platform_get_recording, platform_get_studio, or platform_list_studios. productionId optionally selects the production-default brand kit. Use explicit style fields only for deliberate overrides; they take precedence over the resolved preset. Provide at least one of presetId / show / position / style. Pass expectedRevision from your last read.
editing_set_color_correction
ChatGPTApplies a static color-correction patch to one visual clip or track from its first visible frame. Brightness, contrast, and saturation use -1..1; colorTemperatureKelvin uses 1000..40000 Kelvin. Omitted adjustments preserve their effective values. Use batch with modify_color_correction for advanced or time-varying keyframes. Pass expectedRevision from your last read.
editing_set_magic_audio
ChatGPTEnables or disables Magic Audio (enhanced audio) on a recording track. This is the recommended way to toggle Magic Audio (instead of batch with set_track_magic_audio). Magic Audio applies to the whole track and cannot be scoped to a clip or time range. The legacy batch operation modify_enhanced_audio_mix has the same whole-track scope. Optionally set mixLevel (0..1); omit it to keep the track’s current value (defaults to 1 on first enable). When enabling, enhancedAudio reports whether an enhanced-audio artifact is ready. Pass expectedRevision from your last read.
editing_set_visual_crop
ChatGPTApplies one static normalized crop to a non-recording clip or track from its first visible frame. The service resolves timeline IDs, keyframe time, canvas size, effective visual size, and pixel conversion. Recording speaker tiles use batch update_scene_track_crop instead. Pass expectedRevision from your last read.
editing_validate_edit_plan
ChatGPTUse only immediately before batch to preflight an exact batch without saving. Pass exactly the same editId, operations, and expectedRevision intended for batch, then pass a valid result planHash as batch.validatedPlanHash. Do not use before standalone write tools or for speculative or unrelated operations.
exports_create_edit_with_timeline
ChatGPTCreates a new edit from a recording session: its first timeline is built from the session's recordings and saved as revision 1. The recording itself is not changed. Returns the new edit; use its id as the edit id for later editing calls. Not idempotent: every call creates another edit. Retry only after PRECONDITION_FAILED (a recording's metadata is not ready yet) or SERVICE_UNAVAILABLE; both mean nothing was created. Never retry after any other error, or after an answer that was lost or unclear. UNAUTHORIZED: the caller is not a member of the session's production, or the feature is not enabled for them. NOT_FOUND: the session, its production or the project does not exist. VALIDATION_ERROR: the project is outside that production, a recording failed, or the session has no usable recordings. A recording still processing is placed at its reported or estimated length. The edit stays off the project's edit lists until its first change unless isVisible is true. The answer carries no upload URL or storage key.
exports_create_export
ChatGPTRenders one revision of an edit to a video or audio file. This changes state: it creates a PENDING export and dispatches a Temporal compose workflow, so calling it twice renders the edit twice. It returns the new export immediately, including the revision it pinned — but not the rendered file: s3Key stays null until the compose job reports back, so poll get_export for the outcome (a full-length edit takes minutes, not seconds). Compose settings are normalized server-side and export.useWatermark plus planFeatures are overwritten from the account's plan, so the stored value can differ from what was sent. An edit with no saved RSTL cannot be exported.
exports_get_export
ChatGPTReturns one export by id: its status, the edit and revision it renders, the compose settings, and the S3 keys of the output and its poster frame. status is PENDING, COMPLETED or FAILED — PENDING is not terminal, so keep polling; FAILED is terminal, and the render will not arrive. s3Key is null until the status is COMPLETED, and it is an S3 object key, not a URL — this tool returns no download link. An ID with no export is not an error: the result is export: null. Reads only and changes nothing.
hosting_connect_platform
ChatGPTConnect a podcast to a distribution platform (Spotify, Apple Podcasts, YouTube, Deezer, Amazon Music, iHeart Radio). Each platform has different requirements: - YouTube: returns an OAuth URL that the user must visit to authorize - Spotify, Apple Podcasts: omit url to submit the show for review (the normal path). Pass url only for an RSS-imported podcast to connect a show that is already published there. - Deezer, Amazon Music, iHeart Radio: url is required (the podcast URL on that platform) Preconditions: the podcast needs at least one published episode, and private podcasts are rejected. Use get_platform_links to check connection status afterwards.
hosting_create_episode
ChatGPTCreate a new episode for a podcast. The episode can be created from a Riverside clip (idClip) or from a recording session/take (sessionId). Exactly one source must be provided. If sessionId is unknown, use the platform MCP list_recordings or get_recording tool — the returned id field is the sessionId. If idClip is unknown, ask the user to find it on the project page in Riverside (the platform MCP list_edits tool is currently NOT a reliable source for this ID).
hosting_create_podcast
ChatGPTCreate a new podcast on Riverside. Requires studioId (studio slug), title, description, author, and language. Returns the created podcast with its ID and RSS feed URL. If the studio slug is unknown, use the platform MCP list_studios or get_studio tool — read the slug field (NOT the id, which is the ObjectId used by list_podcasts).
hosting_edit_episode
ChatGPTEdit episode metadata. Only provide the fields you want to update. Can also change episode status (e.g., publish or unpublish).
hosting_edit_podcast
ChatGPTEdit podcast metadata. Only provide the fields you want to update. All fields are optional except podcastId.
hosting_export_podcast_analytics_csv
ChatGPTExport per-episode daily downloads for a podcast as CSV text: one row per episode (Episode, Published, Season, Episode Number), then one column per day from "from" to "to" inclusive. Dates are YYYY-MM-DD and the range may not exceed 90 days. Large podcasts should be exported in smaller windows. Returns the CSV inline, not a download link.
hosting_get_episode
ChatGPTGet full metadata for an episode by ID. Returns all fields including title, description, status, media URLs (audio/video), and publication date.
hosting_get_episode_analytics
ChatGPTGet analytics for episodes. Can retrieve download counts for specific episodes, top episodes by downloads, or recent performance trends. Note: metrics represent downloads for RSS-based platforms and views for YouTube-distributed podcasts.
hosting_get_hosting_config
ChatGPTGet available enums, statuses, and reference data for Riverside hosting. Returns podcast types, episode types/statuses, platform types, available languages, and podcast categories. Call this before creating or editing podcasts/episodes to know valid values.
hosting_get_platform_links
ChatGPTGet all connected platforms and their direct URLs for a podcast. Includes YouTube connection status and RSS feed URLs. Useful for sharing or verifying platform connections.
hosting_get_podcast
ChatGPTGet full metadata for a podcast by ID. Returns all fields including title, description, RSS feed URLs, connected platforms, episode count, and publication status.
hosting_get_podcast_analytics
ChatGPTGet analytics for a podcast. Returns download summary, downloads over time, top countries, and top listening platforms/clients. Note: metrics represent downloads for RSS-based platforms and views for YouTube-distributed podcasts. Use startDate to filter the time period.
hosting_get_podcast_guidelines
ChatGPTGet constraints and best practices for podcast metadata. Returns field limits (title, description, author lengths), allowed values, and recommendations for creating or editing podcasts.
hosting_get_user_context
ChatGPTGet the authenticated user's account info. Returns userId and accountId. Call this first to confirm identity.
hosting_list_episodes
ChatGPTList episodes for a podcast. Returns paginated results with summary metadata. Use offset and limit for pagination.
hosting_list_podcasts
ChatGPTList all podcasts for a studio by its internal ID. Returns a summary of each podcast including ID, title, and publication status. Note: studioId is the internal MongoDB ObjectId, not the studio slug. If unknown, use the platform MCP list_studios or get_studio tool — the returned id field is the studioId.
hosting_upload_cover_art
ChatGPTUpload cover art for a podcast from an image URL. Downloads the image and uploads it to the podcast. Accepts JPEG or PNG, max 10 MB. The image is automatically cropped to a square.
hosting_upload_episode_artwork
ChatGPTUpload artwork for an episode from a public image URL. Replaces the existing image. Accepts JPEG or PNG. imageType "square" sets the episode artwork: 1:1, 1400-3000 px per side, max 10 MB (auto-cropped to a square). imageType "video" sets the 16:9 video thumbnail: at least 640x360 px, max 2 MB (auto-cropped to 16:9; pushed to YouTube when the episode is linked). Pick an image whose aspect ratio matches the chosen type.
media_create_media_upload
ChatGPTUpload a media file so it appears in the editor's "Your Media" library, ready to drop onto the timeline. Step 1 of 2: registers the media (as the authenticated caller) and returns an uploadUrl. The bytes are NOT sent through this tool — after calling it, upload the file directly to uploadUrl (e.g. curl -T <path> -H "Content-Type: <mimeType>" "<uploadUrl>"), then call finalize_media_upload. This requires a client with local filesystem access, such as a desktop app or CLI; a browser-only chat cannot read local files. Requires fileSizeBytes; files over 500 MB and unsupported types are rejected. For video, the poster thumbnail and display resolution are generated on the server at finalize — the caller never needs ffmpeg. Follow the returned instructions.
media_finalize_media_upload
ChatGPTStep 2 of 2. Call after the file bytes have been uploaded to the uploadUrl from create_media_upload. For video, pass the thumbnailUploadUrl too: the server pulls a poster frame from the uploaded file, derives the display resolution, and attaches the thumbnail — the caller never needs ffmpeg. Finalizes the media and returns its id, status, and a read URL. Once finalized, the media appears in the editor's "Your Media" library. Images finalize instantly; video/audio return status "processing" and transcode on the server.
media_get_media
ChatGPTFetch a media item's current state by id. Use it to check whether processing finished: for video/audio status is "processing" while transcoding, then becomes "transcoded" (or "done") when complete, or "failed" on error (processingComplete/failed booleans summarise this). Also returns duration, resolution, the source url, and thumbnailUrl once ready, plus per-artifact fileStatuses (e.g. hls, thumbnail). The media lives in the editor's "Your Media" library.
media_list_media
ChatGPTSearch the media library of one production: the files the user sees in the editor's "Your Media" panel — their own uploads and AI-generated media. Stock, imported and shared library media are not listed. Use it when the user refers to a file by name ("the B-roll image of the letterboard") to get that file's media id, which the editing tools need in order to place it on the timeline. Pass search to match part of a file name, or omit it to browse newest first. Only media that finished processing and is ready to place is listed — to check on a file you just uploaded, call get_media with its id. Returns 20 items per page, with the total and the next page number when more exist.
platform_get_edit
ChatGPTGet a single edit by id, including its parent project and source recording. In the JSON response, take is the source recording. The riversideUrl field is the canonical link to open this edit in the Riverside editor (the editor preview URL) — return it directly when the user wants the link, rather than constructing a URL yourself.
platform_get_production
ChatGPTGet a single production by id, including its child studios.
platform_get_project
ChatGPTGet a single project by id, including its parent studio, recordings and edits. Use as the recommended fan-out: one call returns recordings and edits with ids, cheaper than separate list_recordings/list_edits calls. The riversideUrl field is the canonical link to open this project in Riverside — return it directly when the user wants the link, rather than constructing a URL yourself.
platform_get_recording
ChatGPTGet a single recording by id, including its parent project and studio. For uploads and single-take recordings, use id as sessionId for platform_get_transcript and editing_create_edit_from_recording. The returned status is a backend string, not a closed enum in this schema. riversideUrl is the dashboard/project recording link. The token-bearing previewUrl is omitted by default; set includePreviewUrl: true only after a shareable preview link is explicitly requested, and return the server-provided URL directly rather than constructing a URL. If the opted-in previewUrl is null, no share link is currently available.
platform_get_studio
ChatGPTGet a single studio by id, including its parent production. The riversideUrl field is the canonical link to open this studio in Riverside — return it directly when the user wants the link, rather than constructing a URL yourself.
platform_get_transcript
ChatGPTGet the transcript of a recording by session id. For uploads and single-take recordings, use id as sessionId; the same value feeds editing_create_edit_from_recording. This returns dialogue prose, each line headed by Speaker (m:s.mmm) — one timestamp per sentence, measured from the start of the recording session. Note minutes and seconds are not zero-padded (1:5.000 is 1m5s). Exception: when a recording exposes no offset for a speaker, that speaker is timed from their own track start instead, so their times are not comparable with the other speakers. For word-level times, or for cutting, use editing_read_aligned_transcript.
platform_list_edits
ChatGPTList edits. Pass projectId to scope to a single project when the request is about that project; omit it for broad requests. Results may include soft-deleted edits (deleted: true) — filter these out unless the request is specifically about deleted edits. Returns a compact {total, offset, limit, items} envelope; total is the full unpaged count, so page with limit/offset while total exceeds offset + items.length. Each item's riversideUrl is its canonical link to open that edit in the Riverside editor; return it directly rather than constructing a URL.
platform_list_productions
ChatGPTList all productions the authenticated user has access to. Start here: productions -> projects -> recordings/edits, via studios when needed. Returns a compact {total, offset, limit, items} envelope; total is the full unpaged count, so page with limit/offset while total exceeds offset + items.length.
platform_list_projects
ChatGPTList projects; pass studioId to scope to a single studio when the request is about that studio. Returns a compact {total, offset, limit, items} envelope; total is the full unpaged count, so page with limit/offset while total exceeds offset + items.length. Each item's riversideUrl is its canonical link to open that project in Riverside; return it directly rather than constructing a URL.
platform_list_recordings
ChatGPTList recordings. Omit projectId for broad requests like "my videos" or "all recordings"; only pass it when the current request explicitly scopes to a project, and do not reuse a cached project id for an unscoped request. For uploads and single-take recordings, use id as sessionId for platform_get_transcript and editing_create_edit_from_recording. The returned status is a backend string, not a closed enum in this schema. Returns a compact {total, offset, limit, items} envelope; total is the full unpaged count, so page with limit/offset while total exceeds offset + items.length. Each item's riversideUrl is the dashboard/project recording link; return that field directly rather than constructing a URL. This list never returns the token-bearing previewUrl; use platform_get_recording with includePreviewUrl: true only when a shareable preview link is explicitly needed.
platform_list_studios
ChatGPTList studios; pass productionId to scope to a single production when the request is about that production. Returns a compact {total, offset, limit, items} envelope; total is the full unpaged count, so page with limit/offset while total exceeds offset + items.length. Each item's riversideUrl is its canonical link to open that studio in Riverside; return it directly rather than constructing a URL.
search_recording_transcripts_exact
ChatGPTExact-phrase search over recording/take transcript content across the caller's archive (higher precision than search_riverside's fuzzy matching). Returns compact per-session matches with sessionId, takeId, projectId and up to maxHighlightsPerSession ~200-character transcript fragments, with no word timestamps. Feed sessionId, projectId, and a title to editing_create_edit_from_recording, or use platform_get_transcript for prose. sessionId identifies the recording session rather than the individual take, so for a multi-take recording it may resolve to a sibling take: confirm the intended take with the user first, or start from platform_list_edits if the recording already has an edit. TAKES/recordings only — clip and project transcripts are not searched.
search_riverside
ChatGPTSearch Riverside projects, clips, and recording takes with fuzzy matching, including spoken-word transcript content for takes. Use search_recording_transcripts_exact when the wording must match exactly. For spoken moments, pass a filters entry whose entity is TAKE. Transcript/content matching applies only to takes/recordings. Projects and clips match by title; studios and productions are not searchable entities. Results expose compact public fields, identifiers, and short transcript fragments in highlights.transcription, with no word timestamps and no full transcript. No tool has a parameter named takeId or entityId; takeId is display-only, while the entityId on a CLIP result is the clip ID that social_upload_create accepts as clipId. Global search locates a TAKE result. To edit it, call editing_create_edit_from_recording(sessionId, projectId, title) to create a new editable timeline, then editing_read_aligned_transcript(editId) for word-level times; platform_get_transcript(sessionId) returns dialogue prose instead. A take's sessionId identifies its recording session, not the individual take, so for a multi-take recording it may resolve to a sibling take: confirm the intended take with the user first, or start from platform_list_edits if the recording already has an edit. Results page 10 at a time via nextSearchAfter; there is no limit parameter. Pass explicit null for unused nullable parameters.
social_cancel_upload
ChatGPTCancels a social post before it publishes, so it never reaches the platform. Only a post that has not started publishing can be cancelled — get_upload reports that as cancellable, and a post whose upload is already underway is not, even though it has not appeared on the platform yet. This does not delete anything from the platform. A post that has already published stays live on YouTube, TikTok, Instagram, Facebook, LinkedIn or X, and neither this tool nor any other on this server can take it down — the user must do that on the platform itself. Call get_upload first. If cancellable is false, do not call this tool: tell the user the post has already published, or is publishing now, and that removing it has to happen on the platform. If it is true, show them the platform, the account or channel name, the caption or title, and the scheduled time, and get an explicit yes before calling. Cancelling is irreversible. The post disappears from the Riverside Content Planner and nothing on this server can restore it. Afterwards get_upload and get_upload_status for this uploadId return the same authorization error an unknown id returns, so do not read it back to confirm — this tool's own response is the confirmation. Returns { uploadId, cancelled, message }.
social_connect_social_account
ChatGPTStarts connecting a YouTube, TikTok, Instagram, Facebook, LinkedIn or X account to a studio, so posts can be published to it. Returns a provider authorization link the user opens themselves; nothing is connected until they finish in the browser. Show the user the link and tell them they sign in and approve on the platform's own page, then come back and say they are done. When the user says they finished, call get_connected_platforms and report the account whose platformAccountId is not in this tool's connectedPlatformAccountIds. If connectedPlatformAccountIds is null the before-picture could not be read, so do not guess which row is new — list what is connected now and ask the user which one they just added. If nothing new appears, ask whether the browser tab reported an error, then call this tool again for a fresh link rather than reusing the old one. If the link opens a page saying it has expired, the user needs a new one: call this tool again. Do not call this tool repeatedly to poll: there is no waiting tool, and the user's own confirmation is the signal. Set isAddingAccount when the studio already has an account on this platform and the user wants a second one; Instagram and X use it to force the provider's account chooser. Returns { platform, authUrl, connectedPlatformAccountIds, instructions }, where connectedPlatformAccountIds is the studio's accounts before this connect, or null when that could not be read.
social_disconnect_social_account
ChatGPTDisconnects a social account from a studio, so Riverside can no longer post to it. This is the same action the Riverside web app offers. Every upload still scheduled on this account is cancelled, and nothing on this server can restore it. Say that to the user before calling. Call get_connected_platforms first, show the user the account's name or handle and its platform, and get an explicit yes. Reconnecting later is done with connect_social_account or from the Riverside web app. Facebook is not per-page: one Facebook login owns many Pages, and disconnecting any one of them disconnects EVERY Page under that same login, cancelling all of their scheduled uploads. Pages belonging to a different Facebook login stay connected. Name every Page the user is about to lose — get_connected_platforms lists them — before calling it on Facebook. Returns { platformAccountId, platform, disconnected, message }. An account that was already disconnected returns disconnected: false, which is not an error; platform is null in that case, because only connected accounts report one. Facebook is the exception: it reports disconnected: true whether or not anything was still connected, so it cannot tell you a Page was already gone.
social_get_connected_platforms
ChatGPTList the social media platforms (YouTube, TikTok, Instagram, Facebook, LinkedIn, X) connected to a studio, including posting details such as platformAccountId, YouTube accounts[].channelId for upload_create youtubeData.channelId, X characterLimit for xData.text, TikTok privacyLevelOptions for tiktokData.privacyLevel, postingAvailable, and maxVideoPostDurationSec. Each account also reports scopes, analyticsEnabled and, when analytics is off, analyticsDisabledReason and a message saying how to fix it. If an upstream account-detail fetch fails, an account can return accounts: []; empty accounts does not always mean no accounts are connected.
social_get_publishing_guidelines
ChatGPTReturn per-platform publishing guidelines: metadata fields and their limits, character caps, video duration/size/aspect-ratio constraints, the publishing workflow and its preconditions, and error-code recovery. Call this before composing upload_create metadata so the post passes backend validation. Pass platform to filter to a single platform; omit it to get every platform.
social_get_upload
ChatGPTReturns one social post in full by its uploadId: its schedule, its destination account, and the caption, title and platform options it will publish with, under content. This is the read to do before updating or cancelling a post — it is how you show the user what is there now and confirm the change they want. Read editable, mediaEditable and cancellable rather than the status, and read them independently: they do not move together. editable is on for a scheduled or failed post. cancellable is on for a scheduled one and for one still rendering, so a post can be cancellable but not editable. mediaEditable is the strictest: the video or images may only be swapped while a post is still scheduled. When all three are false the post is already out or mid-publish, and the user must edit or remove it on the platform itself. content shows the current values, for you to relay to the user before an edit. It is not the shape update_upload takes: it carries fields that tool does not accept, and a value it reports as null cannot be sent back. Send update_upload only the fields that are actually changing. It carries no preview image or video URL. Use get_upload_status instead when all you need is whether a publish finished; this tool is the full read. reasonCode and reason are set only for a failed post, and reason is Riverside-authored recovery text to relay, not the platform's. For an X thread, content.children holds the replies in order, each with its own id, and for LinkedIn content.comments holds the first comments in order. update_upload replaces either list wholesale, so send the whole thing back — anything left out is deleted. scheduledAt is null for an immediate publish, and is returned exactly as stored. postUrl links to the live post once it has published and is null before then; it is also null for TikTok, whose URL needs the account handle from get_connected_platforms (https://www.tiktok.com/@{handle}/video/{externalId}), and for Facebook, whose post ids are not addressable by URL. An unknown uploadId, one in another account, and one whose upload was cancelled all come back as the same authorization error, so a cancelled upload cannot be distinguished from one that never existed. Reads only and changes nothing.
social_get_upload_analytics
ChatGPTReports how one published post is doing — views, likes, comments and shares — by its uploadId. Use it to answer "how did my post do?"; list_uploads finds the uploadId when the user does not have one. The numbers are collected on a schedule, not read live, so always relay asOf and never present them as current. Newly published posts are polled every half hour at first and less often as they age. hasData false means nothing has been collected for this post yet; say so rather than reporting zeros. A null metric means the platform reports no such number for this post type — null is not zero. frozen true means the numbers will never change again: X is polled for 5 days after publishing and then retired. reasonCode MISSING_ANALYTICS_SCOPE means the account was connected before analytics permissions were required, so no numbers can exist for any of its posts until the user reconnects it — offer connect_social_account rather than retrying. This is only detected when studioId is passed. granularity "total" gives one number per metric. "daily" adds series, one entry per day with that day's own numbers, already differenced — report them as given and do not add them up or subtract them from each other. A null day in the series is a day with no data, not a zero. Reads only and changes nothing.
social_get_upload_status
ChatGPTReturns the current outcome of one social publish started by upload_create, by its uploadId. This is the only way to learn whether a post actually published: upload_create returns as soon as the publish is accepted, long before the platform has it. status is PENDING, SCHEDULED, COMPLETED or FAILED. Branch on the terminal flag rather than on the status: terminal means nothing further will change on its own. PENDING (still rendering, or being uploaded) and SCHEDULED (queued for scheduledAt) are not terminal. COMPLETED is. FAILED is terminal except in one case — a FAILED upload with reasonCode PLATFORM_CONNECTION_EXPIRED and a scheduledAt returns terminal false, because reconnecting the account can bring that post back; its reason says whether that happens on its own or only if the user accepts a prompt. Treat a post as live only when status is COMPLETED; do not infer it from externalId, which is the platform's own post id and can appear before the whole upload finishes. reasonCode and reason are set only when FAILED, and reason is Riverside-authored recovery text to relay, not the platform's. scheduledAt is null for an immediate publish. This tool returns no post URL and cannot construct one. platform is UPPER_SNAKE_CASE (YOUTUBE, YOUTUBE_SHORTS, TIKTOK, INSTAGRAM, FACEBOOK, LINKEDIN, X); get_connected_platforms uses mixed case and has no Shorts entry, so correlate an account by stripping a _SHORTS suffix and comparing case-insensitively. An unknown uploadId, one in another account, and one whose upload was cancelled all come back as the same authorization error, so a cancelled upload cannot be distinguished from one that never existed. Read access is not simply per-user: an upload this server created carries no production, so any user in its account can read it, while an upload created in the Riverside web app may be scoped to a production and is then readable only by users assigned to that production — an upload in your own account can still be denied. This tool only reads. A SCHEDULED or FAILED upload can be changed with update_upload, but only one that has not gone out yet can be stopped with cancel_upload — read get_upload and branch on its cancellable flag rather than on the status, since a FAILED upload is editable but not cancellable. A COMPLETED one is neither, and an unpublish or delete is not possible through this MCP at all. A PENDING publish has no retry path and must be left to resolve, though one that has not started uploading yet can still be cancelled — get_upload's cancellable flag is what says which. A FAILED one can be rescheduled or republished in place from the Riverside web app, whatever its reasonCode, so before publishing again read this status once more and confirm the original is still FAILED. Reads only and changes nothing.
social_list_uploads
ChatGPTLists the social posts in one studio over a time window, so you can find an upload the user is talking about without them quoting an uploadId. This is the entry point to the upload lifecycle: list_uploads finds it, get_upload reads it in full, update_upload changes it, cancel_upload stops it. Covers posts created anywhere in Riverside, not only ones this server published. With no from/to it returns the next 30 days, so a question about posts already published needs an explicit from/to in the past. Each row carries editable, mediaEditable and cancellable, so you can tell the user what can still be done to a post without a second call. Read those flags rather than the status, and read them independently: a post still rendering is cancellable but not editable, and a failed one is editable but not cancellable. status is PENDING, SCHEDULED, COMPLETED or FAILED, the same vocabulary get_upload_status uses. platform is UPPER_SNAKE_CASE; get_connected_platforms uses mixed case and has no Shorts entry, so correlate an account by stripping a _SHORTS suffix and comparing case-insensitively. includeViews adds views to each row: the post's total so far, collected on a schedule rather than read live, null when nothing has been collected or the platform reports no view count for that post. If you asked for views and a row has no views field at all, the counts could not be read this time — say so rather than reporting no views. get_upload_analytics explains one post's numbers in full, including how current they are. total and hasMore describe the time window on the server, before any platform or status filter you pass is applied, so total can exceed the number of rows returned. The message field states both counts in one line you can relay. postUrl links to the live post once it has published, and is null before then. It is also null for TikTok, whose URL needs the account handle from get_connected_platforms (https://www.tiktok.com/@{handle}/video/{externalId}), and for Facebook, whose post ids are not addressable by URL. Reads only and changes nothing.
social_update_upload
ChatGPTChanges a social post that has not published yet: reschedules it, publishes it immediately, edits its caption, title and platform options, or swaps its video or images. Only a scheduled or failed post can be changed. A post that has already published cannot be edited by this MCP — the user must change it on the platform itself. Before calling, call get_upload, show the user the current values and the exact change you intend to make, and get explicit confirmation — the same contract upload_create follows. Send only the fields that change; an omitted field is left as it is. Send the platform data object that matches the post's own platform and no other: a LinkedIn post takes linkedinData. Passing the wrong one is rejected. publishNow posts to the platform immediately and cannot be undone. It cannot be combined with scheduledAt; use scheduledAt to move a post to a later time, which must be in the future. For an X thread, xData.text changes the first post and xData.children replaces the whole reply list. That list is a diff, not an append: read the thread with get_upload first, edit a copy of the children it returned, and send all of them back, or the replies you left out are deleted. Media can change only while get_upload reports mediaEditable. clipId swaps the video for another clip or edit; a video post's video can be swapped but never removed. The clip or edit you swap in must already be exported or exporting: if the swap is refused with "Clip is not exported yet", tell the user to export it first, and do not retry or create a new post in its place. assets replaces the whole image set with the media ids you send; [] drops every image and is accepted only where the platform publishes text-only posts (LinkedIn, X, Facebook). A video post cannot become an image post, nor the reverse. If the user asks to remove media that cannot be removed, say so. A mediaId in assets is the assetId of an image attached in this chat, or the mediaId from media_create_media_upload + media_finalize_media_upload. thumbnailMediaId sets the custom thumbnail of a YouTube, Instagram or Facebook video post from an image with the same provenance (JPEG or PNG, max 2 MB), and null removes it. It is not an image post; LinkedIn, TikTok and X take none. Re-publishing a failed post clears its failure automatically. For X, the text limit is the account's own characterLimit from get_connected_platforms. Returns the post as it now stands, in the same shape get_upload returns, so you can show the user the result.
social_upload_create
ChatGPTThis action publishes or schedules a post on an external social media platform. Supports YouTube, TikTok, Instagram, Facebook, LinkedIn, and X (Twitter). Use get_connected_platforms first to discover platform accounts and required per-account limits/options. Call get_publishing_guidelines first for per-platform metadata constraints, video limits, and publish error recovery. A post that has not started publishing can be changed with update_upload or stopped with cancel_upload, both of which need the uploadId this tool returns. Call get_upload and branch on its editable and cancellable flags rather than inferring either from the status: a post still rendering from a non-exported clip is cancellable even though it cannot be edited. Cancellation ends when publishing starts, not when the post becomes visible, and once a post has published it can no longer be edited, unpublished or deleted through this MCP. Before asking for final confirmation, tell the user that an immediate publish cannot be undone here. Before calling this tool, show the user a final summary with the destination platform and human-readable account or channel name or handle (not internal IDs); the exact final post content and applicable platform options, including privacy or visibility settings; and whether it will publish immediately or at the scheduled date, time, and timezone. For a non-exported clip, also show the export settings. Obtain explicit confirmation of this summary. Media is one of: clipId (a clip or edit), assets (one image, on X, LinkedIn, Facebook or Instagram), or neither for a caption-only post on X, LinkedIn or Facebook. A Riverside recording cannot be published as it is; it needs a clip or an edit first. A mediaId for assets is the assetId of an image the user attached in this chat, or the mediaId from media_create_media_upload + media_finalize_media_upload. A video post on YouTube, Instagram or Facebook takes an optional thumbnailMediaId: an image from the same sources, JPEG or PNG up to 2 MB, used as its custom thumbnail. It is not an image post (that is assets) and LinkedIn, TikTok and X take none. If that image is deleted from the library before a scheduled post goes out, the post still publishes without it and get_upload shows thumbnailStatus FAILED. Match each platform value to its data object: "YouTube" requires youtubeData with channelId, title, description, and privacyStatus (youtubePlatform is optional); "TikTok" requires tiktokData with title and privacyLevel; "Instagram" requires instagramData with caption; "Facebook" requires facebookData (description is optional); "LinkedIn" requires linkedinData with visibility (description is optional); "X" requires xData with text. For a non-exported clip (a draft / "magic clip" not yet exported), also provide composeSettings to export-then-publish it (tell the user the export defaults and ask if they want to change any; pass {} to accept them); omit composeSettings for an already-exported clip. clipId takes the id of an edit as readily as a clip id, so an edit is published by passing its own id — see the clipId argument. Publish the asset the user named and no other. If its id cannot be published, report that and stop; never substitute a different clip, edit or export, however close a match it looks. Returns { success, results: [{ platform, platformAccountId, success, uploadId, status, scheduledAt, error, message }] }, where error is always present (null when there is none) and message appears only on a WAITING_FOR_GREENLIGHT result. A status of WAITING_FOR_GREENLIGHT means the clip is still exporting and will publish automatically once ready — do NOT show that raw status to the user; instead tell them the clip is processing and will be published once it's ready (relay the accompanying message field). Success here means the publish was accepted, not that the post exists: rendering, scheduling and the platform upload all happen afterwards and can still fail. Never tell the user a post is live off this response alone. Pass each returned uploadId to get_upload_status to learn the real outc…
editing_add_lower_third
Claudeediting_add_text_overlay
Claudeediting_apply_brand
Claudeediting_apply_smart_layout
Claudeediting_apply_smart_mutes
Claudeediting_apply_verified_edit_plan
Claudeediting_batch
Claudeediting_clone_edit
Claudeediting_compare_revisions
Claudeediting_create_edit_from_recording
Claudeediting_cut_time_ranges
Claudeediting_get_asset_metadata
Claudeediting_get_brand
Claudeediting_get_captions_presets
Claudeediting_get_editing_guide
Claudeediting_get_export_publish_data
Claudeediting_get_layout
Claudeediting_get_revision
Claudeediting_get_stock_media
Claudeediting_get_stock_music
Claudeediting_insert_audio
Claudeediting_insert_media_as_scene
Claudeediting_insert_overlay
Claudeediting_insert_stock_media
Claudeediting_list_edit_recording_asset_sessions
Claudeediting_list_layouts
Claudeediting_read_aligned_transcript
Claudeediting_read_timeline_in_range
Claudeediting_remove_fillers
Claudeediting_remove_pauses
Claudeediting_resolve_transcript_selection
Claudeediting_restore_audio_cleanup
Claudeediting_set_brand
Claudeediting_set_captions
Claudeediting_set_color_correction
Claudeediting_set_magic_audio
Claudeediting_set_visual_crop
Claudeediting_validate_edit_plan
Claudemedia_create_media_upload
Claudemedia_finalize_media_upload
Claudemedia_get_media
Claudeplatform_get_edit
Claudeplatform_get_export
Claudeplatform_get_production
Claudeplatform_get_project
Claudeplatform_get_recording
Claudeplatform_get_studio
Claudeplatform_get_transcript
Claudeplatform_list_edits
Claudeplatform_list_exports
Claudeplatform_list_productions
Claudeplatform_list_projects
Claudeplatform_list_recordings
Claudeplatform_list_studios
Claudesearch_recording_transcripts_exact
Claudesearch_riverside
Claudesocial_get_connected_platforms
Claudesocial_get_publishing_guidelines
Claudesocial_upload_create
Claude
