Platform For AI:Generate high-definition long videos using EasyAnimate

On the Service Details page, click View Web App.

In the WebUI, select the pre-trained model path. Configure other parameters as needed.

Click Generate. After about 5 minutes, you can view or download the generated video on the right side of the page.

To get the service URL and token, on the Service Details page, in the Call Information section, click View Call Information.

Call the service to generate a video. The following is a Python request example:

import os
import requests
import json
import base64
from typing import Dict, Any


class EasyAnimateClient:
    """
    EasyAnimate EAS Service API Client.
    """

    def __init__(self, service_url: str, token: str):
        if not service_url or not token:
            raise ValueError("The service URL (service_url) and token cannot be empty")
        self.base_url = service_url.rstrip('/')
        self.headers = {
            'Content-Type': 'application/json',
            'Authorization': token
        }

    def update_model(self, model_path: str, edition: str = "v3", timeout: int = 300) -> Dict[str, Any]:
        """
        Updates and loads the specified model version and path.

        Args:
            model_path: The path of the model within the service, such as "/mnt/models/Diffusion_Transformer/EasyAnimateV3-XL-2-InP-512x512".
            edition: The model edition. Default value: "v3".
            timeout: The request timeout period in seconds. Model loading is slow, so we recommend that you set a long timeout period.
        """
        # 1. Update the edition.
        requests.post(
            f"{self.base_url}/easyanimate/update_edition",
            headers=self.headers,
            json={"edition": edition},
            timeout=timeout
        ).raise_for_status()

        # 2. Update the model path and wait for the model to load.
        print(f"Sending a request to load the model: {model_path}")
        response = requests.post(
            f"{self.base_url}/easyanimate/update_diffusion_transformer",
            headers=self.headers,
            json={"diffusion_transformer_path": model_path},
            timeout=15000
        )
        response.raise_for_status()
        return response.json()

    def generate_video(self, prompt_textbox: str, **kwargs) -> bytes:
        """
        Generates a video based on the prompt.

        Args:
            prompt: The English positive prompt.
            **kwargs: Other optional parameters. For more information, see the parameter description table below.

        Returns:
            The binary data of the video in MP4 format.
        """
        payload = {
            "prompt_textbox": prompt_textbox,
            "negative_prompt_textbox": kwargs.get("negative_prompt",
                                                  "The video is not of a high quality, it has a low resolution..."),
            "width_slider": kwargs.get("width_slider", 672),
            "height_slider": kwargs.get("height_slider", 384),
            "length_slider": kwargs.get("length_slider", 144),
            "sample_step_slider": kwargs.get("sample_step_slider", 30),
            "cfg_scale_slider": kwargs.get("cfg_scale_slider", 6.0),
            "seed_textbox": kwargs.get("seed_textbox", 43),
            "sampler_dropdown": kwargs.get("sampler_dropdown", "Euler"),
            "generation_method": "Video Generation",
            "is_image": False,
            "lora_alpha_slider": 0.55,
            "lora_model_path": "none",
            "base_model_path": "none",
            "motion_module_path": "none"
        }

        response = requests.post(
            f"{self.base_url}/easyanimate/infer_forward",
            headers=self.headers,
            json=payload,
            timeout=1500
        )
        response.raise_for_status()

        result = response.json()
        if "base64_encoding" not in result:
            raise ValueError(f"Invalid API return format: {result}")

        return base64.b64decode(result["base64_encoding"])


# --- Example ---
if __name__ == "__main__":
    try:
        # 1. Configure service information. Replace the placeholders with the actual service endpoint and token. We recommend that you set them as environment variables.
        EAS_URL = "<eas-service-url>"
        EAS_TOKEN = "<eas-service-token>"

        # 2. Create a client.
        client = EasyAnimateClient(service_url=EAS_URL, token=EAS_TOKEN)

        # 3. Load the model. After the service is deployed, no model is loaded by default. Before you send a generation request, you must call update_model at least once to specify the model to use. To switch to a different model later, call this method again.
        client.update_model(model_path="/mnt/models/Diffusion_Transformer/EasyAnimateV3-XL-2-InP-512x512")

        # 4. Generate a video.
        video_bytes = client.generate_video(
            prompt_textbox="A beautiful cat playing in a sunny garden, high quality, detailed",
            width_slider=672,
            height_slider=384,
            length_slider=72,
            sample_step_slider=20
        )

        # 5. Save the video file.
        with open("api_generated_video.mp4", "wb") as f:
            f.write(video_bytes)
        print("The video is saved as api_generated_video.mp4.")

    except requests.RequestException as e:
        print(f"Network request error: {e}")
    except (ValueError, KeyError) as e:
        print(f"Data or parameter error: {e}")
    except Exception as e:
        print(f"An unknown error occurred: {e}")

The following table describes the service interface input parameters.