Download every output

listProjectOutputs is the one list of everything a project can give you. getProject embeds the same list in outputs.

const { data: outputList } = await rask.exports.listProjectOutputs({ path: { project_id: projectId } });

output_list = client.exports.list_project_outputs(project_id)

outputList, err := client.Exports.ListProjectOutputs(ctx, projectID)
if err != nil {
	return err
}

OutputList outputList = rask.exports().listProjectOutputs(projectId).data();

$outputList = $rask->exports->listProjectOutputs($projectId);

curl "https://api.rask.ai/v3/projects/$PROJECT_ID/outputs" \
  -H "Authorization: Bearer $RASK_API_KEY"

{
  "object": "output",
  "kind": "dubbed_video",
  "format": "mp4",
  "language": "es-es",
  "available": true,
  "unavailable_reason": null,
  "outdated": false,
  "version": { "number": 7, "job_id": "91c3e7b2-4f8a-4d6e-9b1c-7a3e5f2d8c60", "produced_at": "2026-11-03T09:22:31Z" },
  "url": "https://...",
  "expires_at": "2026-11-03T11:15:02Z",
  "subtitles_request": null,
  "filename": "Q3 webinar teaser_es-es_dubbed_video.mp4"
}

An output comes in one of three shapes, and available is true for the first two:

A file: url is an absolute presigned link, valid 1 hour after the read. It needs no key. Read the outputs again for a fresh link. filename is a suggested name, and the link downloads the file under it.
A rendered subtitle variant: url is null and subtitles_request holds the parameters to render it.
Not available: url is null and unavailable_reason says why.

What each kind is

The last column names the plan features an output needs. Without them, it reports not_in_plan.

`kind`	What it is	Plan features
`source`	The original media
`cover_image`	The cover frame
`dubbed_video`	The dubbed video
`dubbed_audio`	Dubbed audio with background	`audio_download`
`voice_track`	The voice-only track	`audio_download`
`dubbed_subtitles`	The subtitles snapshot at the last dub (srt, vtt)	`subtitle_download`
`source_subtitles`	Source subtitles from the current transcript, one cue per segment	`subtitle_download`
`source_subtitles_speakers`	The same with `[SPEAKER_NN]:` labels	`subtitle_download`
`target_subtitles`	Target subtitles from the current transcript, one cue per segment	`subtitle_download`
`target_subtitles_speakers`	The same with `[SPEAKER_NN]:` labels	`subtitle_download`
`burned_subtitles_video`	The dubbed video with burned-in subtitles	`burned_subtitles`
`lipsync_video`	The lip-synced video	`lipsync` and `lipsync_download`
`lipsync_burned_subtitles_video`	The lip-synced video with burned-in subtitles	`burned_subtitles`
`onscreen_video`	The video with translated on-screen text	`onscreen`
`localized_video`	The final video of a localization run	`onscreen` when on-screen is the run’s last stage, else `lipsync` and `lipsync_download`

Each subtitle kind is listed twice, once per format (srt and vtt). An audio project lists only source, dubbed_audio, voice_track and the subtitle kinds.

Why an output is not available

`unavailable_reason`	Meaning	What to do
`not_produced`	Not produced yet, or (`lipsync_video`) cleared by a later dub	Run the work that produces it
`in_progress`	Being produced	Wait for the job
`not_in_plan`	The plan does not allow the download	Tell the user; see `GET /v3/plan`
`dub_payment_required`	Subtitles of a project whose text is still closed	Wait for the auto-dub or call createDub. See Paid text
`not_generated`	Never requested for this project	Request it, for example with createExport
`restoring`	A restore of the project’s archived files is running	Wait for the restore, or call createFileRestore for a job to wait on
`temporarily_unavailable`	The file could not be read or linked just now	Read the outputs again later

Is it still current?

outdated says whether the output still matches the project. version names the work that produced it: its job_id, the transcript number and produced_at. job_id is null for work started in the web app or API v2, and number is set only on the dub outputs. The source, the cover and the rendered subtitle variants have no version.

Dubbed video, audio, voice track and subtitles snapshot: outdated when a segment with target text has dub_state outdated or not_dubbed, or the transcript or a voice changed since the last dub.
Burned-in subtitle videos: outdated after a later dub.
On-screen video: outdated after a later dub, or after a later lip-sync when it was rendered over the lip-synced video.
Localized video: the dub rule, or its final stage’s result is outdated, or a newer run succeeded.
Lip-synced video: always false, because a later dub removes it. The output then reports not_produced, and the job’s result.video keeps the file.
Rendered subtitle variants: always current.

Subtitles

subtitles_request holds the parameters for getProjectSubtitles, which renders from the current transcript and stores nothing. The file comes back inside the answer, in content.

curl "https://api.rask.ai/v3/projects/$PROJECT_ID/subtitles?language=target&format=vtt&speaker_labels=false&cue=segment" \
  -H "Authorization: Bearer $RASK_API_KEY" \
  | jq -r '.content' > target.vtt

Parameter	Values
`language`	`target` (default) or `source`
`format`	`srt` (default) or `vtt`
`speaker_labels`	`false` (default), or `true` to prefix cues with `[SPEAKER_NN]:`
`cue`	`segment` (default) writes one cue per segment. `line` splits long segments into lines, as the `dubbed_subtitles` snapshot does

Target subtitles leave out segments that have no translation. Segments with unusable times are left out too, and listed in skipped_segment_ids. Before the project has a transcript, the request answers 409 project_not_ready.

Burned-in subtitles

createExport burns the target subtitles of the last dub (the dubbed_subtitles snapshot) into the video, free of charge. The file appears in the outputs when the export job succeeds: burned_subtitles_video for source_video: dubbed, lipsync_burned_subtitles_video for source_video: lipsync. Without that video, the request answers 409 project_not_dubbed. One export per source video runs at a time: another answers 409 export_in_progress, whose job_id names the running export when the API started it.

const { data: job } = await rask.exports.createExport({
  path: { project_id: projectId },
  body: { type: 'burned_subtitles', source_video: 'dubbed' },
});

job = client.exports.create_export(project_id, body={"type": "burned_subtitles", "source_video": "dubbed"})

var body api.CreateExportRequest
if err := body.FromBurnedSubtitlesExportInput(api.BurnedSubtitlesExportInput{
	Type:        api.BurnedSubtitlesExportInputTypeBurnedSubtitles,
	SourceVideo: api.ExportSourceVideoDubbed,
}); err != nil {
	return err
}
job, err := client.Exports.CreateExport(ctx, projectID, body)
if err != nil {
	return err
}

Job job = rask.exports().createExport(projectId, BurnedSubtitlesExportInput.builder()
        .sourceVideo(ExportSourceVideo.DUBBED)
        .build()).data();

$job = $rask->exports->createExport($projectId, ['type' => 'burned_subtitles', 'source_video' => 'dubbed']);

curl -X POST "https://api.rask.ai/v3/projects/$PROJECT_ID/exports" \
  -H "Authorization: Bearer $RASK_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{"type": "burned_subtitles", "source_video": "dubbed"}'

Clips of single segments

Two places hold a segment’s audio. Segment.audio is the latest clip, replaced by each new take. A SegmentClip in a segment_generation job’s result is a stable take that nothing overwrites. Both links need audio_download in the plan; without it they are null.

Archived files

An archived file still gets a url, but the download answers 403. While a restore runs, every stored file of the project reports restoring. createFileRestore starts a free file_restore job, which typically takes hours. If nothing is archived, the job succeeds within moments with files_restored: 0. While one restore runs, another answers 409 restore_in_progress with its job_id.

const { data: job } = await rask.exports.createFileRestore({ path: { project_id: projectId } });

job = client.exports.create_file_restore(project_id)

job, err := client.Exports.CreateFileRestore(ctx, projectID)
if err != nil {
	return err
}

Job job = rask.exports().createFileRestore(projectId).data();

$job = $rask->exports->createFileRestore($projectId);

curl -X POST "https://api.rask.ai/v3/projects/$PROJECT_ID/file-restores" \
  -H "Authorization: Bearer $RASK_API_KEY" \
  -H "Idempotency-Key: $(uuidgen)"

The whole program

download_outputs.py

"""Download everything a project has: python download_outputs.py PROJECT_ID"""
import pathlib
import sys

from rask_client import call, download

project_id = sys.argv[1]
target = pathlib.Path(project_id)
target.mkdir(exist_ok=True)

for output in call("GET", f"/projects/{project_id}/outputs")["data"]:
    if not output["available"]:
        print(f"{output['kind']}: {output['unavailable_reason']}")
    elif output["url"]:
        download(output["url"], target / output["filename"])
    else:
        rendered = call("GET", f"/projects/{project_id}/subtitles", params=output["subtitles_request"])
        (target / output["filename"]).write_text(rendered["content"], encoding="utf-8")

Get started

AI agents

Recipes

Concepts

Errors

Account

Usage

Catalogs

Uploads

Media

Projects

Exports

Glossaries

Jobs

Transcript

Segments

Versions

Speakers

Voices

Voice clones

Dubbing

Lipsync

Onscreen

Download every output

What each kind is

Why an output is not available

Is it still current?

Subtitles

Burned-in subtitles

Clips of single segments

Archived files

The whole program

​What each kind is

​Why an output is not available

​Is it still current?

​Subtitles

​Burned-in subtitles

​Clips of single segments

​Archived files

​The whole program

What each kind is

Why an output is not available

Is it still current?

Subtitles

Burned-in subtitles

Clips of single segments

Archived files

The whole program