Name: LTX-2 Retake – Edit Video with Text | $0.15/call | API.market
Brand: magicapi
SKU: api-magicapi-edit-images-with-precision-lightricks-ltx-2-retake
Availability: InStock
Author: API Market

Shashank Agarwal

# 📸 AI-Powered Image Retake API - Edit Shots Precisely (LTX-2-Retake)

## Overview
The LTX-2-Retake API allows you to take any shot and edit specific sections with high accuracy and speed. Using cutting-edge AI technology, you can rephrase, change actions, and adjust camera angles effortlessly.

## Features
- Precision editing of specific video sections
- Ability to modify video content based on a textual prompt
- Change actions, camera angles, and visual effects
- Fast processing ensuring minimal wait times

## Use Cases
- **Film Industry**: Adjust scenes post-shooting to match directorial vision without reshooting.
- **Social Media Influencers**: Edit videos on the go, removing imperfections or adding effects with ease.
- **Marketing**: Create engaging promotional content by tweaking and perfecting video ads quickly.
- **Education**: Enhance instructional videos by highlighting key sections or modifying sequences.
- **Security**: Adjust and enhance footage for clearer visual analysis.

## Visual Examples
### Overview
Example of input video with lens flare, and output video after AI-edit to remove the lens flare.

#### Input
![Example Input Video](https://blog.api.market/wp-content/uploads/2025/12/ltx-2-retake-api-market.mp4)

#### Output
![Example Output Video](https://blog.api.market/wp-content/uploads/2025/12/ltx-2-retake-output-api-market.mp4)

## Pricing
- **Pay As You Go (PAYG)**: Pay only for what you use.
- **1 API Unit = 1 Video Processed**
- **GET Requests** to check prediction status are free.
- 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/edit-images-with-precision-lightricks-ltx-2-retake`

### Authentication
Authentication is handled via API key. Include your API key in the request header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API uses asynchronous processing for predictions. The typical flow is:
1. Submit a prediction request to the POST endpoint
2. Receive a prediction ID in the response
3. Poll the GET endpoint with the prediction ID to check status
4. Continue polling until the prediction is complete

The processing time varies depending on the complexity of the request. Your code should implement:
- A polling interval of 1 second between status checks
- A maximum timeout of 600 seconds (10 minutes)
- Status checking logic that continues while status is "starting" or "processing"
- Result handling when status becomes "succeeded"
- Error handling when status becomes "failed" or timeout is reached

### Endpoints
#### Create a Prediction
```bash
# Example for creating a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/edit-images-with-precision-lightricks-ltx-2-retake/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "mode": "replace_video",
      "video": "https://blog.api.market/wp-content/uploads/2025/12/ltx-2-retake-api-market.mp4",
      "prompt": "remove the lens flare",
      "duration": 6,
      "start_time": 0
    }
  }'
```

#### Check Prediction Status
```bash
# Example for checking prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/edit-images-with-precision-lightricks-ltx-2-retake/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

## Status Codes
- **200 OK**: Request successful
- **201 Created**: Resource successfully created
- **400 Bad Request**: Invalid input parameters or malformed request
- **401 Unauthorized**: Missing or invalid API key
- **403 Forbidden**: Valid API key but insufficient permissions
- **404 Not Found**: Resource not found
- **429 Too Many Requests**: Rate limit exceeded
- **500 Internal Server Error**: Server-side error
- **503 Service Unavailable**: Service temporarily unavailable

## Rate Limits
This API does not enforce specific rate limits, but frequent polling (more than 1 request per second) is discouraged to ensure fair usage and maintain performance.

## Error Handling
### Example Error Response
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'image' is required",
    "status": 400
  }
}
```
### Handling Errors
- **Invalid Parameters**: Ensure all required fields are provided and correctly formatted.
- **Authentication Failures**: Verify API key is valid and included in the request header.
- **Rate Limits**: Introduce back-off strategies and retry mechanisms for 429 status codes.
- **Server Errors**: Implement retries for transient errors (e.g., 500 status) with exponential backoff.

## Implementation Guide

### Example Code
#### JavaScript
```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/edit-images-with-precision-lightricks-ltx-2-retake";

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({ 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 between checks

  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 status and return if completed
    if (prediction.status === "succeeded") {
      return prediction.output;
    }

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

    // Wait before next poll
    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/edit-images-with-precision-lightricks-ltx-2-retake"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }

    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"input": input_data}
    )

    if response.status_code != 200:
        raise Exception(f"API error: {response.status_code} {response.text}")

    prediction = response.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 between checks

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

    while time.time() - start_time < MAX_TIMEOUT:
        # Check prediction status
        response = requests.get(
            f"{BASE_URL}/predictions/{prediction_id}",
            headers=headers
        )

        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.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
# cURL example for creating a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/edit-images-with-precision-lightricks-ltx-2-retake/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "mode": "replace_video",
      "video": "https://blog.api.market/wp-content/uploads/2025/12/ltx-2-retake-api-market.mp4",
      "prompt": "remove the lens flare",
      "duration": 6,
      "start_time": 0
    }
  }'

# Response will contain a prediction ID like this:
# {"id": "abcd1234", "status": "starting"}

# cURL example for checking prediction status (replace abcd1234 with the actual ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/edit-images-with-precision-lightricks-ltx-2-retake/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"

# Note: You need to repeatedly poll this endpoint until the status is "succeeded"
```

### Performance Optimization
- **Batch Requests**: If processing multiple videos, batch them to reduce the overhead of individual requests.
- **Efficient Polling**: Implement exponential backoff to avoid excessive polling of status endpoints.

## FAQ
**Q**: How do I get started with the API?  
**A**: Start by signing up on API.market and obtaining your API key. Use the authentication header to access the API.

**Q**: What do I do if my prediction fails?  
**A**: Check the error message in the response for details. Common causes include invalid input data and exceeding duration limits.

**Q**: How long does it take to process a prediction?  
**A**: Processing time varies based on the complexity of the request, typically completing within a few minutes.

**Q**: Can I process multiple videos simultaneously?  
**A**: Yes, the API supports concurrent requests, allowing you to process multiple videos at the same time.

## 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.

Modify existing video clips with text prompts. Change camera angles, rephrase dialogue, or adjust actions. From $0.15/call. Try it free on API.market.