Name: Infinite Zoom – Text to Video | Free · $5/mo | API.market
Brand: magicapi
SKU: api-magicapi-infinite-zoom-image-to-video-api
Availability: InStock
Rating: 4.00 (1 reviews)
Author: API Market

Shashank Agarwal

# 🔁 Infinite Zoom Image-to-Video API – Seamless Animations (Stable Diffusion)

## Overview
The Infinite Zoom Text-to-Video API leverages advanced inpainting technology to repeatedly zoom into the center of an image, seamlessly generating new surrounding areas as it goes. This creates mesmerizing, infinitely looping videos or GIFs that smoothly transition deeper into the scene. Whether you want to accentuate artistic details, design immersive animations, or explore imaginative scenarios, this API can bring your ideas to life with continuous zoom sequences and smooth transitions.

## Features
- Seamless Infinite Zoom: Dynamically zoom further into the image while filling in newly revealed areas.  
- Multiple Output Formats: Choose between MP4 or GIF output for easy sharing or embedding.  
- Flexible Iterations: Control how many times the inpainting and zoom cycles occur, allowing a fine-tuned level of depth.  
- Text-Prompted Expansion: Use descriptive prompts to guide the inpainting in the newly exposed areas.  
- High-Quality Rendering: Generates creative and visually consistent visuals with minimal artifacts.

## Use Cases
1. Artistic Showcases: Present a painting or digital artwork that continuously reveals new layers of detail.  
2. Marketing Animations: Create looping product reveals or immersive brand animations for social media.  
3. Educational Content: Demonstrate zoomed-in details of maps, diagrams, or scientific imagery.  
4. Fantasy Scenes & Storytelling: Visualize surreal environments by zooming into imaginative worlds.  
5. Ambient Visuals: Generate eye-catching, seamless loops for video backgrounds or event projections.

## Examples
Below is a sample video generated by the API, demonstrating the infinite zoom effect for a prompt such as “A path going into the woods” with two inpainting iterations:

![Infinite Zoom Video Output Example](https://replicate.delivery/pbxt/iPWPdknk7e1fkEECe8AhzVVE6lceedKnpx6JxIHkEswr0ofeHA/infinit_zoom.mp4)

Notice how the scene keeps zooming in while the borders are filled in with content that matches the overall style.

## Pricing
- 1 API unit equals processing one image for the infinite zoom animation.  
- GET requests to check prediction status (GET /api/v1/magicapi/infinite-zoom-image-to-video-api/predictions/{id}) do not consume any API units.  
- Flexible pricing tiers are available depending on your usage volume.

## API Documentation

### Base URL
All requests should be made to:  
```
https://prod.api.market/api/v1/magicapi/infinite-zoom-image-to-video-api
```

### Authentication
Include your API key in the request header:
```
x-magicapi-key: YOUR_API_MARKET_KEY
```
Failure to provide a valid API key will result in a 401 Unauthorized response.

### Asynchronous Processing
This API uses asynchronous processing. You will:
1. Submit a prediction request by POSTing to /predictions.  
2. Receive a prediction ID in the response.  
3. Poll the GET /predictions/{id} endpoint to check its status.  
4. When the status is "succeeded," retrieve the final result from the output.  

A recommended approach is to poll every 1 second, for up to 600 seconds (10 minutes). If the status remains "starting" or "processing" beyond that timeframe, you should handle it as a timeout.

### Endpoints

#### 1. Create a Prediction
• Endpoint:  
  ```
  POST /api/v1/magicapi/infinite-zoom-image-to-video-api/predictions
  ```
• Description:  
  Initiates a new infinite zoom generation with the specified parameters.

• Request Body (JSON):
```json
{
  "input": {
    "prompt": "A path going into the woods",
    "inpaint_iter": 2,
    "output_format": "mp4"
  }
}
```
- prompt (required): A text description guiding the inpainting context.  
- inpaint_iter (optional): Number of iterations of inpainting. Defaults to 2.  
- output_format (optional): "mp4" or "gif". Defaults to "mp4".

• Example cURL:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/infinite-zoom-image-to-video-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "prompt": "A path going into the woods",
      "inpaint_iter": 2,
      "output_format": "mp4"
    }
  }'
```

• Successful Response (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "a2527c5074fc0cf9fa6015a40d75d080d1ddf7082fabe142f1ccd882c18fce61",
  "status": "starting",
  "created_at": "2025-04-21T10:44:08.613Z"
}
```
- id: Unique identifier for the prediction (used for checking status).  
- status: Current status of the prediction.  
- created_at: Timestamp of when the prediction was created.  

#### 2. Get Prediction Status and Results
• Endpoint:  
  ```
  GET /api/v1/magicapi/infinite-zoom-image-to-video-api/predictions/{id}
  ```
• Description:  
  Retrieves the latest status of the prediction, along with any output if available.

• Path Parameter:  
- id (required): The unique prediction ID returned from the create endpoint.

• Example cURL:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/infinite-zoom-image-to-video-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

• Successful Response (200 OK) when completed:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": {
    "mp4": "https://replicate.delivery/pbxt/iPWPdknk7e1fkEECe8AhzVVE6lceedKnpx6JxIHkEswr0ofeHA/infinit_zoom.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: Will be one of "starting", "processing", "succeeded", "failed", or "canceled".  
- output: Contains the final URLs (either .mp4 or .gif).  

## Status Codes
- 200 OK: The request succeeded.  
- 201 Created: Resource was successfully created.  
- 400 Bad Request: Input parameters are invalid or malformed.  
- 401 Unauthorized: Missing or invalid API key.  
- 403 Forbidden: API key is valid but lacks required permissions.  
- 404 Not Found: The specified resource could not be found.  
- 429 Too Many Requests: You have exceeded the request rate limit.  
- 500 Internal Server Error: A generic server error occurred.  
- 503 Service Unavailable: The service is temporarily unavailable.

## Rate Limits
Your rate limit depends on your subscription tier. If you exceed your allocated requests in a given time window, you will receive a 429 Too Many Requests response. You should then:
- Wait before sending new requests.
- Optionally consider upgrading your plan for higher throughput.

## Error Handling
Errors are returned in JSON format with a relevant HTTP status code:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'prompt' is required",
    "status": 400
  }
}
```
- code: Machine-readable error code.  
- message: A human-readable description of the error.  
- status: The HTTP status for quick reference.

To handle errors:
- Check the HTTP status code.
- Inspect the code or message within the JSON error object.
- Correct the request parameters or manage your request rate accordingly.
- Retry for transient or rate-limited (429) errors after waiting an appropriate timeframe.

## Implementation Guide

Below are examples demonstrating how to make requests to the API and handle asynchronous processing.

### Example Code

#### JavaScript (Node.js) Example
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/infinite-zoom-image-to-video-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-magicapi-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

  const startTime = Date.now();

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

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

    const prediction = await response.json();

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

    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");
}

// Usage example:
// const inputData = {
//   prompt: "A path going into the woods",
//   inpaint_iter: 2,
//   output_format: "mp4"
// };
// createAndWaitForPrediction(inputData)
//   .then(result => console.log("Final output:", result))
//   .catch(console.error);
```

#### Python Example
```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/infinite-zoom-image-to-video-api"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-magicapi-key": API_KEY
    }
    response = requests.post(f"{BASE_URL}/predictions", headers=headers, json={"input": input_data})

    if response.status_code != 201 and 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
    return poll_for_results(prediction_id)

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

    while time.time() - start_time < MAX_TIMEOUT:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}",
                                headers={"x-magicapi-key": API_KEY})
        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")

# Usage example:
# input_data = {
#     "prompt": "A path going into the woods",
#     "inpaint_iter": 2,
#     "output_format": "mp4"
# }
# result = create_and_wait_for_prediction(input_data)
# print("Final output:", result)
```

#### cURL Example
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/infinite-zoom-image-to-video-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "prompt": "A path going into the woods",
      "inpaint_iter": 2,
      "output_format": "mp4"
    }
  }'

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

# Step 2: Poll the prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/infinite-zoom-image-to-video-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- Use a moderate polling interval of ~1 second to avoid unnecessary requests.  
- Merge multiple requests when practical to reduce overhead.  
- Keep track of API usage to stay within your plan’s limits.

## FAQ
1. Q: Can I generate a GIF instead of an MP4?  
   A: Yes. Set `"output_format": "gif"` in the request body.  

2. Q: How long do videos usually take to generate?  
   A: Time depends on prompt complexity and number of inpainting iterations. Simple prompts may take seconds, whereas more complex ones can approach a minute or more.

3. Q: Does creating multiple iterations cost more?  
   A: Each request consumes one API unit per processed image. Larger or more complex images won’t consume additional “units,” though it could take longer to process.

4. Q: What if the status remains "processing" after 10 minutes?  
   A: The API might be under heavy load or dealing with a complex request. We recommend aborting at 10 minutes and retrying.

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

Generate mesmerizing infinite zoom videos from text prompts. Powered by Stable Diffusion. Free 5 calls/mo, from $4.99/mo. Start free on API.market.

Infinite Zoom – Text to Video | Free · $5/mo | API.market

🔁 Infinite Zoom Image-to-Video API – Seamless Animations (Stable Diffusion)

FREE

MagicAPI

PAYG

START

ULTRA

ELITE

MEGA

GIGA

BULK

Effortlessly transform text prompt into mesmerizing infinite zoom videos with inpainting and smooth transitions powered by Stable Diffusion.

🔁 Infinite Zoom Text To Video Generation API – Seamless Animations (Stable Diffusion)