Source: https://ailoot.ai/models/en/runway-aleph-2/
Canonical: https://ailoot.ai/models/en/runway-aleph-2/
Language: en

# Runway: Aleph 2.0

[Markdown](https://ailoot.ai/models/en/runway-aleph-2/index.md) · [JSON](https://ailoot.ai/models/en/runway-aleph-2/facts.json)

## [Runway: Aleph 2.0](https://ailoot.ai/models/en/runway-aleph-2/)

Aleph 2.0 edits existing video through targeted text instructions and keyframe guidance. Use it to replace an object, change a background, wardrobe, lighting or style, while directing which details of the original scene should stay intact.

- [**Ailoot Ultra · Video** `POST /v1/videos` `runway/aleph-2`](https://ailoot.ai/models/en/runway-aleph-2/#method-0)

About the model

This description covers the model’s capabilities. Available in Ailoot inputs, outputs and options are listed for the selected method below.

Aleph 2.0 is Runway’s in-context video editing model. It transforms existing traditional or generated footage using a written instruction and optional keyframe guidance. Its intended workflow changes the requested part of a scene while preserving its surrounding composition, lighting and details, making it useful for a product replacement, wardrobe change, background transformation, relighting or visual restyling without recreating the whole scene from a text brief.

Start with a direct action and the transformation you want: add, remove, replace, change, relight or restyle. For a product substitution, identify the visible object and describe its replacement, then state which hand movement, camera motion and surrounding setting should remain. For a seasonal scene, describe the weather or light that should change. A concise, targeted instruction gives a clearer editing goal than a general request to improve the entire clip.

Keyframe guidance establishes how the edited result should look at a particular moment. Choose a frame that clearly shows the target: a wide view for a background change, or a closer view for a small feature or accessory. In Runway’s Edit Studio workflow, a still-frame edit can be previewed and refined before that selected version guides the video transformation. Compare the edited frame with the source for the subject details, edges and objects you intend to preserve, then use it as the visual direction for the clip.

The producer API supports source videos from 2 to 30 seconds and up to five optional keyframe images placed at specified timestamps. Keep each guiding image associated with its intended point in the source, and use a small number of clear changes rather than a collection of conflicting visual targets. Aleph 2.0 is distinct from the older Gen-4 Aleph model; the producer identifies its API model separately. A keyframe-guided edit is also different from asking a text-to-video model to create an unrelated shot.

Edit Studio’s documented preparation rules use conventional aspect ratios, source resolution between 480p and 1080p, and 24–30 frames per second, with no more than ten cuts or shot changes. It recommends 720p or 1080p source material; over-30-fps footage is downsampled and over-30-second uploads are trimmed in that interface. These are the preparation rules of the producer editing workflow. Choose a source segment that shows the complete event you want to edit and whose subject remains visible where the change must carry through.

The model can propagate a changed background, clothing, object, light or style across the footage. An extra-motion instruction is useful when the edit needs a new action that is absent from the source and would not follow from the keyframe alone, such as a visual effect developing over time. Many edits need no extra-motion brief because the model animates the keyframe adjustment within the existing scene. Describe a new motion specifically, and keep it separate from the visual change that the keyframe already establishes.

The producer editing workflow applies an edit to the complete video by default and can limit it to a selected timeline range. Retain the original clip so the selected result can be compared with the source and used for a focused follow-up. A practical review looks beyond the chosen frame: check the beginning, middle, end, any cut and the period when the target is briefly obscured. The useful artifact is a revised clip whose requested transformation remains consistent through time while the important unchanged elements retain their role.

MP4 is the default playback and sharing artifact. Runway’s eligible full-video Edit Studio workflow also offers ProRes as a MOV file with PCM audio, or a ZIP of individual PNG frames for compositing. ProRes profiles range from 422 Proxy through 4444 XQ. Edits limited to a timeline range return MP4, and the output format is chosen when generation starts rather than changed after the finished result. Select the producer export form for the subsequent editing task while keeping it separate from the model’s core visual-editing capability.

For a useful finished edit, compare the intended substitution, lighting or style with the keyframe and inspect surrounding details that were not meant to change. Preserve the successful version and revise the specific instruction or guiding frame responsible for a mismatch. Aleph 2.0’s role is transforming source footage through a clear visual target; producing a new soundtrack, changing an application’s behavior or finishing a separate broadcast delivery pipeline are additional tasks around the edited video.

**Ailoot Ultra · Video** `POST /v1/videos` `runway/aleph-2`

[`runway/aleph-2`](https://ailoot.ai/models/en/#m=runway%2Faleph-2&route=Ultra&caller=runway%2Faleph-2&fmt=videos)

Runway /`runway/aleph-2`

### Overview

Aleph 2.0 edits existing video through targeted text instructions and keyframe guidance. Use it to replace an object, change a background, wardrobe, lighting or style, while directing which details of the original scene should stay intact.

Accepted inputs

Text · Images · Audio · Video

Results

Video

### Available in Ailoot · inputs & methods

**Ailoot Ultra · Video** `POST /v1/videos`

Input types

`text`, `image`, `audio`, `video`

Output types

`video`

| Field | Type | Requirement | Values & limits | Default |
| --- | --- | --- | --- | --- |
| Field`model` | Type`string` | RequirementRequired | Values & limits runway/aleph-2 | Default— |
| Field`input_references` | Type`array` | RequirementRequired | Values & limits Minimum items: 1 Maximum items: 1 | Default— |
| Field`prompt` | Type`string` | RequirementRequired | Values & limits Minimum length: 1 | Default— |

Method parameters and lifecycle

| Parameter | Contract |
| --- | --- |
| Parameter`content_type` | Contractapplication/json |
| Parameter`required` | Contractmodel, input\_references, prompt |
| Parameter`material_types` | Contracttext, image, audio, video |
| Parameter`material_conditions` | ContractUse exactly one actual completed owned video asset content URL with its returned signature. The asset owner, type and stored byte witness must match the request. |

Lifecycle: `asynchronous_job_then_owned_outputs`

`GET /v1/videos/{request_id}` · actual returned id or polling\_url

`GET /v1/videos/{request_id}/content`

### Pricing

##### How the final charge is calculated

The displayed rates estimate the cost before generation. The final charge is calculated from the cost recorded for the original generation. Measured output duration and forecast quantities are not the final billable quantity.

Tariff references do not add request options. Supported parameters are listed for the selected method.

Fast mode

Not specified When fast mode is selected

Flex mode

Not specified When flex mode is selected

Maximum reasoning effort

Not specified When maximum reasoning effort uses the default adjustment

#### Estimated rates for comparison

#### Prices by configuration

Match each charge to the conditions shown. Use one rate for each set of alternative configurations. Apply the minimum-charge rule shown for that configuration.

| Configuration | Rate schedule | Forecast quantity | Charge component | Billing unit | Billing conditions | Minimum charge rule | Charge |
| --- | --- | --- | --- | --- | --- | --- | --- |
| ConfigurationBase token rates | Rate scheduleBase rate | Forecast quantity— | Charge component— | Billing unit— | Billing conditions— | Minimum charge rule— | Charge Input · Input tokens · Estimate for comparison only **—** / 1K tokens Output · Output tokens · Estimate for comparison only **—** / 1K tokens Input · Cache read · Estimate for comparison only **—** / 1K tokens Input · Cache write · Estimate for comparison only **—** / 1K tokens Input · Cache write, 1 hour · Estimate for comparison only **—** / 1K tokens |
| ConfigurationVideo price | Rate schedule— | Forecast quantity— | Charge component— | Billing unitper video second | Billing conditionsNo additional condition is declared in this pricing key. | Minimum charge rule— | Charge Output · Video price · Estimate for comparison only **$0.56** per video second |
| ConfigurationGeneration minimum | Rate schedule— | Forecast quantity— | Charge componentMinimum charge | Billing unitminimum generation charge | Billing conditionsNo additional condition is declared in this pricing key. | Minimum charge ruleYes | Charge total · Generation minimum · Estimate for comparison only **$1.12** minimum generation charge Minimum charge per generation; apply it as a minimum, not an extra fee. No minimum duration is implied. |
| ConfigurationEstimated generation cost | Rate schedule— | Forecast quantityone generation estimate | Charge component— | Billing unit— | Billing conditions— | Minimum charge rule— | Charge Output · Estimated generation cost · Estimate for comparison only **$0.56** estimate before generation This estimate is not an additional charge or a fixed rate for the completed generation. |

Ailoot reserves an estimated amount before a request. After the result, it settles the final charge from measured usage. Streaming settlement uses the final usage record. [How reservation and settlement work →](https://ailoot.ai/docs/en/billing/reserve/)

### Example requests

#### Ailoot Ultra · Video

Use actual input and retain the complete result

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_INPUT_REFERENCES_JSON:?Set the actual documented input value}"
export AILOOT_INPUT_REFERENCES_JSON
: "${AILOOT_PROMPT:?Set the actual documented input value}"
export AILOOT_PROMPT
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
request={'model': 'runway/aleph-2', 'input_references': '${ACTUAL_OWNED_INPUT_REFERENCES}', 'prompt': '${ACTUAL_EDIT_PROMPT}'}
request['input_references']=json.loads(os.environ['AILOOT_INPUT_REFERENCES_JSON'])
request['prompt']=os.environ['AILOOT_PROMPT']
Path('request.json').write_text(json.dumps(request,ensure_ascii=False),encoding='utf-8')
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/videos \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o response.bin
# Retain the complete response and headers, every actual output, original returned identifiers and all usage fields. Recover the original operation without submitting creation again.
```

### Receive and save results

#### Ailoot Ultra · Video

- `GET /v1/videos/{request_id}`
- `GET /v1/videos/{request_id}/content`

##### Save all completed assets

GET all completed assets

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_STATUS_FILE:?Set the actual completed status JSON file}"
export AILOOT_STATUS_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
from urllib.parse import urlsplit,urljoin
f=Path(os.environ["AILOOT_STATUS_FILE"])
if not f.is_file():raise SystemExit("Choose the actual completed status file")
r=json.loads(f.read_text())
if r.get("status")!="completed" or not isinstance(r.get("data"),list) or not r["data"]:raise SystemExit("Wait for a completed status with asset paths")
urls=[]
for x in r["data"]:
    if not isinstance(x,str) or "\n" in x or "\r" in x:raise SystemExit("Invalid asset path")
    u=urljoin("https://api.ailoot.ai",x)
    z=urlsplit(u)
    if z.scheme!="https" or z.netloc!="api.ailoot.ai" or z.username or z.password:raise SystemExit("Use the actual Ailoot asset paths from status")
    urls.append(u)
Path("asset-urls.txt").write_text("\n".join(urls)+"\n")
PY_REQUEST
index=0
while IFS= read -r asset_url; do
  curl --fail-with-body --silent --show-error "$asset_url" \
    -H "Authorization: Bearer $AILOOT_API_KEY" -o "video-${index}.mp4"
  index=$((index + 1))
done < asset-urls.txt
```

##### Keep all completed results

Save every completed video or returned file; retrieve every actual returned asset URL.

Retain the complete response and headers, every actual output, original returned identifiers and all usage fields. Recover the original operation without submitting creation again.

##### If the original response needs checking

Keep X-Client-Request-ID, X-Ailoot-Task-Id and actual returned id/polling\_url. Continue the original job; do not submit creation again.

Response fields

| Field | Type |
| --- | --- |
| Field`id` | Type |
| Field`status` | Type |
| Field`data[]` | Type |
| Field`outputs[]` | Type |

### Aliases

#### Model aliases

**Ailoot Ultra** [`runway/aleph-2`](https://ailoot.ai/models/en/#m=runway%2Faleph-2&route=Ultra&caller=runway%2Faleph-2&fmt=videos)

#### Method path aliases

Use the method paths shown above.

#### Related caller IDs

[`runway/aleph-2`](https://ailoot.ai/models/en/#m=runway%2Faleph-2&route=Ultra&caller=runway%2Faleph-2&fmt=videos)

FAQ · Runway: Aleph 2.0

What inputs and results are available?

`POST /v1/videos` · `runway/aleph-2`: `text`, `image`, `audio`, `video` → `video`

Which fields does the request use?

`POST /v1/videos` · `runway/aleph-2`: `model`, `input_references`, `prompt`

Connect Ailoot to Claude Code, OpenCode, Hermes or your own app.

## The company and its project portfolio

The company and its project portfolio: millions of customers; monthly sales in the billions.

## Buy tokens at a discount.

Subscription discounts for regular use. Promo codes offer up to 50% off token purchases.

Subscription

Choose a discounted plan for your regular requests.

Promo code: up to 50% off

Enter your code at checkout. The price updates to reflect the current promotion.

Spending in your history

The model, tokens and amount are recorded for each request.

[Choose a subscription](https://ailoot.ai/docs/en/billing/subscriptions/) · [View model prices](https://ailoot.ai/models/en/)

## Connect the API to a product you sell.

Use Ailoot in SaaS, apps and bots under its official service offer and licence agreement. Request a reseller licence for resale.

Commercial application

Add text, image, video and audio generation to paid features in your service.

Reseller licence

Send a description of your project and how you provide access. Request written terms for use and resale.

Documents on the website

The service offer, licence agreement and data processing policy are available before you connect.

[Request a reseller licence](mailto:support@ailoot.ai) · [Service offer and licence agreement](https://ailoot.ai/legal/offer?lang=en)

## Ailoot · The company and its project portfolio





Ailoot combines established operating experience, a large client base, stable service and ongoing KPI control.





The company and its project portfolio: millions of customers; monthly sales in the billions.





Ailoot brings that operating experience to API access for AI features in customer products, agents, applications and automations.
