Create Dynamic GIFs from Text with the lucataco/hotshot-xl Cognitive Actions

23 Apr 2025
Create Dynamic GIFs from Text with the lucataco/hotshot-xl Cognitive Actions

In today's fast-paced digital environment, visual content is king. The ability to transform text into dynamic visuals opens up a world of possibilities for developers. The lucataco/hotshot-xl API provides a powerful Cognitive Action that allows you to generate GIFs from text prompts using an advanced image generation model. This article will guide you through the process of integrating the "Generate GIF from Text" action into your applications, showcasing its capabilities and potential use cases.

Prerequisites

Before you start using the Cognitive Actions, ensure you have the following:

  • API Key: You'll need an API key from the Cognitive Actions platform to authenticate your requests.
  • Environment Setup: Make sure you have a development environment ready to make HTTP requests (e.g., Python with the requests library).

Authentication typically involves passing your API key in the headers of your requests to access the Cognitive Actions services.

Cognitive Actions Overview

Generate GIF from Text

The Generate GIF from Text action allows you to create dynamic GIFs based on text prompts. This action leverages the Hotshot-XL model, optimized for speed and compatibility with the Stable Diffusion XL framework.

Input

The input for this action is structured as follows:

  • seed (integer, optional): A random seed for generating consistent outputs. If left blank, a random seed will be generated.
  • steps (integer, optional): The number of denoising steps to perform, ranging from 1 to 500. Default is 30.
  • prompt (string, required): The text prompt that guides the content of the output. The default is "a camel smoking a cigarette, hd, high quality".
  • saveAsMp4 (boolean, optional): Determines the output file format. Set to True for MP4, or False for GIF. Defaults to False.
  • outputWidth (integer, optional): The width of the output in pixels, with predefined options. Default is 672 pixels.
  • outputHeight (integer, optional): The height of the output in pixels, with predefined options. Default is 384 pixels.
  • schedulerType (string, optional): Selects a scheduler for processing steps. Default is "EulerAncestralDiscreteScheduler".
  • negativePrompt (string, optional): Specifies undesired elements in the output prompt. Defaults to "blurry".

Here’s an example of the JSON payload required to invoke this action:

{
  "seed": 6226,
  "steps": 30,
  "prompt": "go-pro video of a polar bear diving in the ocean, 8k, HD, dslr, nature footage",
  "saveAsMp4": false,
  "outputWidth": 672,
  "outputHeight": 384,
  "schedulerType": "EulerAncestralDiscreteScheduler",
  "negativePrompt": "blurry"
}

Output

Upon successful execution, the action returns a URL pointing to the generated GIF. Here's an example output:

https://assets.cognitiveactions.com/invocations/e7e5800b-1af4-4cc0-8a1a-209e06933726/79ea2e19-747a-425f-97a1-fcb7f37882e9.gif

This URL can be used to access and display the GIF in your application.

Conceptual Usage Example (Python)

Below is a conceptual example of how you might call the Cognitive Actions execution endpoint in Python:

import requests
import json

# Replace with your Cognitive Actions API key and endpoint
COGNITIVE_ACTIONS_API_KEY = "YOUR_COGNITIVE_ACTIONS_API_KEY"
COGNITIVE_ACTIONS_EXECUTE_URL = "https://api.cognitiveactions.com/actions/execute" # Hypothetical endpoint

action_id = "d83778f0-479d-4761-a1be-81b342f45bbb" # Action ID for Generate GIF from Text

# Construct the input payload based on the action's requirements
payload = {
    "seed": 6226,
    "steps": 30,
    "prompt": "go-pro video of a polar bear diving in the ocean, 8k, HD, dslr, nature footage",
    "saveAsMp4": False,
    "outputWidth": 672,
    "outputHeight": 384,
    "schedulerType": "EulerAncestralDiscreteScheduler",
    "negativePrompt": "blurry"
}

headers = {
    "Authorization": f"Bearer {COGNITIVE_ACTIONS_API_KEY}",
    "Content-Type": "application/json"
}

try:
    response = requests.post(
        COGNITIVE_ACTIONS_EXECUTE_URL,
        headers=headers,
        json={"action_id": action_id, "inputs": payload}  # Hypothetical structure
    )
    response.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)

    result = response.json()
    print("Action executed successfully:")
    print(json.dumps(result, indent=2))

except requests.exceptions.RequestException as e:
    print(f"Error executing action {action_id}: {e}")
    if e.response is not None:
        print(f"Response status: {e.response.status_code}")
        try:
            print(f"Response body: {e.response.json()}")
        except json.JSONDecodeError:
            print(f"Response body: {e.response.text}")

In this example, replace YOUR_COGNITIVE_ACTIONS_API_KEY with your actual API key. The action_id corresponds to the "Generate GIF from Text" action. The payload is structured based on the required input fields.

Conclusion

The Generate GIF from Text action from the lucataco/hotshot-xl API is a powerful tool for developers looking to create engaging visual content from textual descriptions. With its flexibility and ease of integration, you can enhance your applications by adding dynamic GIFs that capture users' attention.

Explore potential use cases such as social media automation, content marketing, or interactive storytelling to fully leverage the capabilities of this Cognitive Action. Happy coding!

← Back to All Articles