Skip to main content

Get Engines List

Retrieves the list of available Stability AI engines for image generation.

Common Properties​

  • Name - The custom name of the node.
  • Color - The custom color of the node.
  • Delay Before (sec) - Waits in seconds before executing the node.
  • Delay After (sec) - Waits in seconds after executing node.
  • Continue On Error - Automation will continue regardless of any error. The default value is false.
info

If the ContinueOnError property is true, no error is caught when the project is executed, even if a Catch node is used.

Inputs​

  • Connection Id - The connection ID from the Connect node (optional if API Key is provided directly).

Options​

  • API Key - Stability AI API key (optional if using Connection ID). You can provide the API key directly instead of using a Connect node.

Output​

  • Engines List - Array of available Stability AI engines with their details including:
    • Engine ID (e.g., "stable-diffusion-v1-5")
    • Engine name
    • Engine description
    • Engine type
    • Supported features

How It Works​

The Get Engines List node queries the Stability AI API to retrieve information about all available image generation engines. When executed, the node:

  1. Validates the connection or creates a temporary client using provided credentials
  2. Sends a request to the Stability AI engines endpoint
  3. Retrieves the list of available engines
  4. Returns the engine details as a structured object

Requirements​

  • Either a valid Connection Id from Connect node OR direct API Key credentials
  • Active Stability AI account with API access

Error Handling​

The node will return specific errors in the following cases:

  • Invalid or missing credentials (both Connection Id and API Key are empty)
  • Connection not found (when using Connection Id)
  • API authentication errors (401)
  • API rate limit errors (429)
  • API service errors (500, 503)

Usage Notes​

  • You can use this node in two ways:
    1. With Connect node: More efficient for multiple operations
    2. With direct API key: Simpler for single operations
  • The engine list helps you discover available models for image generation
  • Different engines have different capabilities, costs, and performance characteristics
  • Engine IDs from this list can be used in TextToImages, ImageToImages, and other generation nodes
  • The engine list may change as Stability AI adds or deprecates models

Common Engines​

Based on the current Stability AI platform, common engines include:

  • stable-diffusion-xl-1024-v1-0 - Latest SDXL model for high-quality 1024x1024 images
  • stable-diffusion-xl-1024-v0-9 - Previous SDXL version
  • stable-diffusion-v1-5 - Classic Stable Diffusion 1.5 model
  • stable-diffusion-512-v2-1 - Stable Diffusion 2.1 for 512x512 images
  • stable-inpainting-512-v2-0 - Specialized inpainting engine
  • esrgan-v1-x2plus - Image upscaling engine (2x)
  • stable-diffusion-x4-latent-upscaler - AI-powered 4x upscaling

Examples​

Example 1: Get Engines Using Connect Node​

Inputs:

  • Connection Id: (from Connect node)

Flow:

Connect → Get Engines List → (process engine data)

Output Example:

[
  {
    "id": "stable-diffusion-v1-5",
    "name": "Stable Diffusion v1.5",
    "description": "High-quality image generation model",
    "type": "text-to-image"
  },
  {
    "id": "stable-diffusion-xl-1024-v1-0",
    "name": "Stable Diffusion XL 1.0",
    "description": "Latest SDXL model for 1024x1024 images",
    "type": "text-to-image"
  }
]

Example 2: Get Engines with Direct API Key​

Options:

  • API Key: (your credential)

Use Case: Simple script to check available engines without setting up a full flow.

Example 3: Dynamic Engine Selection​

Flow:

Get Engines List
  → Filter engines (e.g., find latest SDXL)
  → Store engine ID in variable
  → TextToImages (use selected engine)

Purpose: Automatically select the best available engine for your use case.

Example 4: Engine Capability Check​

Flow:

Get Engines List
  → Check if specific engine is available
  → If available: proceed with generation
  → If not: use fallback engine or notify user

Use Case: Ensure your automation uses an available engine, with fallback options.

Best Practices​

  1. Cache Results:

    • Engine lists don't change frequently
    • Consider caching the results to avoid unnecessary API calls
    • Refresh periodically (e.g., daily) to catch new engines

  2. Error Handling:

    • Always handle API errors gracefully
    • Have fallback engines in case preferred engine is unavailable
    • Log engine availability for debugging

  3. Engine Selection:

    • Choose engines based on your specific needs:
      • SDXL for highest quality
      • v1.5 for balanced performance and cost
      • v2.1 for specific artistic styles
    • Consider cost vs. quality trade-offs

  4. Validation:

    • Validate engine IDs before using them in generation nodes
    • Check engine capabilities match your requirements
    • Test with different engines to find optimal results

Tips​

  • Use this node at the start of your flow to validate engine availability
  • Store the engines list in a variable for reference throughout your flow
  • Compare engine features to choose the best one for your use case
  • Check Stability AI's documentation for detailed engine specifications
  • Some engines are optimized for specific tasks (text-to-image, inpainting, upscaling)