Name: Runway Gen4-Aleph – AI Video Editing | $0.2/call | API.market
Brand: magicapi
SKU: api-magicapi-ai-video-editing-generation-api
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎬 Ultra-Fast Video Editing & Generation API (Gen4-Aleph)

## Overview
Gen4-Aleph is a powerful AI-driven video editing and generation API that enables developers to quickly transform, edit, and produce high-quality videos with minimal effort. Whether you need to add a specific style, replace backgrounds, or apply creative effects, Gen4-Aleph’s advanced AI model delivers fast, reliable results. This API is specifically designed for high throughput and near-instant previews, making it optimal for rapid prototyping or large-scale production use.

## Features
- Instant video transformations based on text prompts (e.g., “make it winter”)  
- Support for custom aspect ratios (16:9, 9:16, 4:3, etc.)  
- Optional reference images to influence style or content  
- Configurable random seed for reproducible outputs  
- Outputs in a shareable, downloadable video format  
- Asynchronous processing with a simple polling mechanism  

## Use Cases
1. **Marketing & Advertising**  
   Generate eye-catching video ads that adapt to seasonal themes or brand-specific styles.

2. **Film & Media Production**  
   Speed up post-production by applying color grading or stylistic transformations at scale.

3. **Social Media Content Creation**  
   Quickly reformat videos for different platforms (e.g., 16:9 for YouTube, 9:16 for TikTok).

4. **E-Commerce Product Videos**  
   Transform product demonstration videos with different backgrounds or effects without manual editing.

5. **Education & Training**  
   Dynamically tailor instructional videos with text-prompted overlays or contextual changes.

## Visual Examples

### Input Video Example
Here is a short 5-second sample input video used for a transformation request:
![Input video example - short 5s clip](https://replicate.delivery/xezq/cfzezDWlUogXCEeVhG2qFmR5JMkB7ZXpa8ej7bDp6CRX8CNUB/tmp0v9ykzlp.mp4)

### Output Video Example
Here is an example of the transformed output video after applying the prompt "make it winter":
![Output video example - winter transformation effect](https://replicate.delivery/xezq/rMbukKckeO2PX6rYC3ihXK09Kb073VeszOHf1yE7urXmcwPqA/tmp6q6l1p7j.mp4)

These visual examples illustrate how Gen4-Aleph can take a simple input video and turn it into a visually enhanced or stylistically altered clip based on textual instructions.

## Pricing
- Pay As You Go (PAYG): Only pay for what you use  
- 1 API unit = 1 image processed (for this video-specific API, each prediction request consumes credits accordingly)  
- Checking prediction status via GET /api/v1/magicapi/ai-video-editing-generation-api/predictions/{id} is free (no API units consumed)  
- No monthly subscription fees or usage limits—simple per-call pricing  

## API Documentation

### Base URL
All API requests should be made to:  
```
https://prod.api.market/api/v1/magicapi/ai-video-editing-generation-api
```

### Authentication
Use your API key in the request header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
This API processes predictions asynchronously. The typical workflow is:

1. POST a prediction request to /predictions  
2. Receive a prediction ID in the response  
3. Poll GET /predictions/{id} with the ID to check the status  
4. Once the status is "succeeded", the output video is ready  

Expect some processing time based on the request complexity. Implement:
- A 1-second interval between status checks  
- A 600-second (10-minute) maximum timeout  
- Logic to handle “starting” or “processing” statuses until completion  
- Handling for “succeeded” (output available) or “failed” (error scenario)  

### Endpoints

#### 1. Create a Prediction
• **POST** /api/v1/magicapi/ai-video-editing-generation-api/predictions  
Create a new prediction request to transform or generate video.

Example request:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/ai-video-editing-generation-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "3d37185b6195904e35fa22116ae8e0fc810faf57c3f45d570d79d065ca258c41",
    "input": {
      "video": "https://replicate.delivery/xezq/cfzezDWlUogXCEeVhG2qFmR5JMkB7ZXpa8ej7bDp6CRX8CNUB/tmp0v9ykzlp.mp4",
      "prompt": "make it winter",
      "aspect_ratio": "16:9"
    }
  }'
```

Example successful response (HTTP 201):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "3d37185b6195904e35fa22116ae8e0fc810faf57c3f45d570d79d065ca258c41",
  "status": "starting",
  "created_at": "2025-08-17T10:19:19.464Z"
}
```

#### 2. Retrieve Prediction Status & Results
• **GET** /api/v1/magicapi/ai-video-editing-generation-api/predictions/{id}  
Check the status and, when available, retrieve the generated output.

Example request:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/ai-video-editing-generation-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Example successful response (HTTP 200):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://replicate.delivery/xezq/rMbukKckeO2PX6rYC3ihXK09Kb073VeszOHf1yE7urXmcwPqA/tmp6q6l1p7j.mp4",
  "created_at": "2023-01-01T12:00:00.000Z",
  "started_at": "2023-01-01T12:00:05.000Z",
  "completed_at": "2023-01-01T12:01:00.000Z"
}
```

## Status Codes
- **200 OK**: Request successful  
- **201 Created**: Resource (prediction) successfully created  
- **400 Bad Request**: Invalid parameters or malformed request  
- **401 Unauthorized**: Missing or invalid API key  
- **403 Forbidden**: Valid API key, but insufficient permissions  
- **404 Not Found**: The specified resource or prediction was not found  
- **429 Too Many Requests**: Request rate limit exceeded  
- **500 Internal Server Error**: A server-side error occurred  
- **503 Service Unavailable**: Service is temporarily unavailable  

## Rate Limits
Depending on overall system usage, the API may employ rate limiting to ensure consistent service for all users. If you receive a **429 Too Many Requests** error, reduce your request rate before retrying.

## Error Handling
If an error occurs, the response will generally contain an "error" field describing the issue. For example:

```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'video' is required",
    "status": 400
  }
}
```

Common errors and suggested solutions:
- **Invalid Parameter**: Check if all required fields (video, prompt) are provided.  
- **Unauthorized**: Ensure your x-api-market-key is correct.  
- **Timeout**: Long-running predictions might fail if they exceed the maximum allowed time. Consider reducing complexity or splitting large jobs.  

## Implementation Guide

### Example Code

#### JavaScript (Node.js)  
```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/ai-video-editing-generation-api";

async function createAndWaitForPrediction(inputData) {
  try {
    // Step 1: Create the prediction
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-market-key": apiKey
      },
      body: JSON.stringify({
        version: "3d37185b6195904e35fa22116ae8e0fc810faf57c3f45d570d79d065ca258c41",
        input: inputData
      })
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }

    const prediction = await response.json();
    const predictionId = prediction.id;

    // Step 2: Poll for results with timeout
    return await pollForResults(predictionId);
  } catch (error) {
    console.error("Error:", error);
    throw error;
  }
}

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function pollForResults(predictionId) {
  const MAX_TIMEOUT = 600000; // 600 seconds (10 minutes)
  const POLL_INTERVAL = 1000; // 1 second

  const startTime = Date.now();

  while (Date.now() - startTime < MAX_TIMEOUT) {
    // Check prediction status
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: {
        "x-api-market-key": apiKey
      }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${response.statusText}`);
    }

    const prediction = await response.json();

    // Check if completed
    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    // Handle failure
    if (prediction.status === "failed") {
      throw new Error(`Prediction failed: ${prediction.error || "Unknown error"}`);
    }

    await delay(POLL_INTERVAL);
  }

  throw new Error("Prediction timed out after 10 minutes");
}
```

#### Python
```python
# Python example with proper polling and timeout
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/ai-video-editing-generation-api"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }
    
    resp = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={
            "version": "3d37185b6195904e35fa22116ae8e0fc810faf57c3f45d570d79d065ca258c41",
            "input": input_data
        }
    )
    
    if resp.status_code != 201:
        raise Exception(f"API error: {resp.status_code} {resp.text}")
    
    prediction = resp.json()
    prediction_id = prediction["id"]
    
    # Step 2: Poll for results with timeout
    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600  # 600 seconds (10 minutes)
    POLL_INTERVAL = 1  # 1 second

    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < MAX_TIMEOUT:
        resp = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers=headers)
        
        if resp.status_code != 200:
            raise Exception(f"API error: {resp.status_code} {resp.text}")
        
        prediction = resp.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]
        if prediction["status"] == "failed":
            error_msg = prediction.get("error", "Unknown error")
            raise Exception(f"Prediction failed: {error_msg}")
        
        time.sleep(POLL_INTERVAL)
    
    raise Exception("Prediction timed out after 10 minutes")
```

#### cURL
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/ai-video-editing-generation-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "3d37185b6195904e35fa22116ae8e0fc810faf57c3f45d570d79d065ca258c41",
    "input": {
      "video": "https://replicate.delivery/xezq/cfzezDWlUogXCEeVhG2qFmR5JMkB7ZXpa8ej7bDp6CRX8CNUB/tmp0v9ykzlp.mp4",
      "prompt": "make it winter"
    }
  }'

# Example response:
# {
#   "id": "ufawqhfynnddngldkgtslldrkq",
#   "status": "starting"
# }

# Step 2: Check prediction status periodically
curl -X GET "https://prod.api.market/api/v1/magicapi/ai-video-editing-generation-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Poll until "status" is "succeeded"
```

### Performance Optimization
- **Efficient Polling**: Keep the 1-second polling interval; avoid sending excessive requests.  
- **Parallel Requests**: You can initiate multiple predictions in parallel if needed. Just ensure each is polled independently.  
- **Prompt Engineering**: For faster, more accurate results, keep prompts concise and relevant.  

## FAQ
1. **How large can my input video be?**  
   The input video must be less than 16MB. Only 5 seconds of the input clip will be used for transformation.

2. **Can I specify custom dimensions or aspect ratios?**  
   Yes, you can choose from several aspect ratios including 16:9, 9:16, 4:3, 3:4, 1:1, and 21:9.

3. **What if the prediction fails?**  
   An error message will be returned in the response. Handle “failed” status by logging the message and possibly retrying with different parameters.

4. **Are creation and retrieval calls separately charged?**  
   You pay for each successful transformation request. GET requests to retrieve the prediction status are free.

5. **How do I ensure consistent results?**  
   Use a fixed seed for reproducible results. Adjust the seed parameter in your request.

## Contact Us
If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello[at]api.market.

Transform and generate high-quality video with text prompts. Edit scenes, add effects, or change styles instantly. From $0.2/call. Try it free on API.market.

Runway Gen4-Aleph – AI Video Editing | $0.2/call | API.market

🎬 Ultra-Fast Video Editing & Generation API (Gen4-Aleph)

PAYG

MagicAPI

Edit, transform, and generate high-quality videos instantly with Gen4-Aleph’s advanced AI – perfect for rapid creative workflows and dynamic content creation.