ComfyUI API calls

Export the workflow API as a JSON file

Before making API calls, build and debug your workflow in the ComfyUI WebUI. Verify that the workflow successfully generates images. After debugging, go to the ComfyUI interface and click Workflow > Export (API). Your browser downloads a JSON file containing the workflow definition.

The JSON file describes how the current workflow operates.

{
  "3": {
    "inputs": {
      "seed": 740511732689542,
      "steps": 20,
      "cfg": 8,
      "sampler_name": "euler",
      "scheduler": "normal",
      "denoise": 1,
      "model": [
        "4",
        0
      ],
      "positive": [
        "6",
        0
      ],
      "negative": [
        "7",
        0
      ],
      "latent_image": [
        "5",
        0
      ]
    },
    "class_type": "KSampler",
    "_meta": {
      "title": "K sampler"
    }
  },
  "4": {
    "inputs": {
      "ckpt_name": "sd-v1-5-inpainting.ckpt"
    },
    "class_type": "CheckpointLoaderSimple",
    "_meta": {
      "title": "Load Checkpoint"
    }
  },
  "5": {
    "inputs": {
      "width": 512,
      "height": 512,
      "batch_size": 1
    },
    "class_type": "EmptyLatentImage",
    "_meta": {
      "title": "Empty Latent Image"
    }
  },
  "6": {
    "inputs": {
      "text": "beautiful scenery nature glass bottle landscape, , purple galaxy bottle,",
      "clip": [
        "4",
        1
      ]
    },
    "class_type": "CLIPTextEncode",
    "_meta": {
      "title": "CLIP Text Encode (Prompt)"
    }
  },
  "7": {
    "inputs": {
      "text": "text, watermark",
      "clip": [
        "4",
        1
      ]
    },
    "class_type": "CLIPTextEncode",
    "_meta": {
      "title": "CLIP Text Encode (Prompt)"
    }
  },
  "8": {
    "inputs": {
      "samples": [
        "3",
        0
      ],
      "vae": [
        "4",
        2
      ]
    },
    "class_type": "VAEDecode",
    "_meta": {
      "title": "VAE Decoding"
    }
  },
  "9": {
    "inputs": {
      "filename_prefix": "ComfyUI",
      "images": [
        "8",
        0
      ]
    },
    "class_type": "SaveImage",
    "_meta": {
      "title": "Save Image"
    }
  }
}

Publish the API

After preparing the workflow JSON file, configure an API access endpoint for your ComfyUI function. Switch to the API Call tab and click Publish API.

Modify GPU specifications and elastic policies

When configuring the ComfyUI API operation, set the function’s resource specifications based on your expected workload and performance requirements. Consider the following parameters:

• GPU specifications: Select GPU-accelerated instances with different types and configurations to process API call requests. ComfyUI workflows vary significantly in computational complexity and resource consumption. Test your workflow to evaluate processing time and cost across GPU specifications, then select the optimal configuration.

• Elastic policy:

  • Pay-as-you-go mode: This mode uses a pay-as-you-go billing method. You are not charged for compute resources when no requests are active. For sparse invocations, cold starts may occur, which delays the response to the first request.

  • Express mode: Caches ComfyUI in a provisioned snapshot, incurring a minimal snapshot storage fee. This approach avoids cold starts and significantly improves response speed for infrequent calls. If the number of required instances exceeds the number of provisioned snapshots, on-demand instances may still be launched. In such cases, some requests might experience a cold start.

After publishing the API, the platform automatically generates an API endpoint for external use. Use the API call documentation on the page and the JSON file you exported earlier to construct an API request for your AI image generation service.

HTTP image generation

WebSocket image generation

This operation follows the same logic as HTTP mode. Input parameters are passed through websocket.send().

Get status

Retrieves the status of an image generation task. Because FaaS is stateless, you must configure persistent storage to ensure status information is retained correctly.

Save to a file system: Mount NAS or OSS to the function instance. The file is saved to {mount_directory}/output/serverless_api.

Synchronous image generation

If you only need the final image and do not require progress updates, use a synchronous HTTP call.

import requests
import json

# Enter your public request address
endpoint = "https://xxx.xxx.fcapp.run"


def txt2img(prompt):
    resp = requests.post(f"{endpoint}/api/serverless/run?output_oss=true", json=prompt)

    return resp.json()


with open("./api.json", "r", encoding="utf-8") as f:
    result = txt2img(json.loads(f.read()))
    images = result["data"]["results"]
    for image in images:
        # The output will be serverless-api-output/b74f33c0-69ba-4e4b-b584-6700890b7f51.png
        print(image["output"]["oss"]["object"])

Streaming image generation

To monitor image generation progress in real time, use a synchronous HTTP call and read the streaming output.

import requests
import json

# Enter your public request address
endpoint = "https://xxx.xxx.fcapp.run"


def txt2img(prompt):

    with requests.post(
        f"{endpoint}/api/serverless/run?output_oss=true&stream=true",
        json=prompt,
        stream=True,
    ) as response:
        for line in response.iter_lines():
            # Only lines starting with data: are data lines
            if line.startswith(b"data: "):
                data = json.loads(line[6:])
                # As the image generation progresses, the current node status is output
                # Some possible lines are as follows
                # {'type': 'status', 'data': {'status': {'exec_info': {'queue_remaining': 1}}, 'sid': '200c62b4-111f-4994-a4a4-20a28c944408'}}
                # {'type': 'executing', 'data': {'node': '4'}}
                # {'type': 'status', 'data': {'status': {'exec_info': {'queue_remaining': 1}}}}
                # {'type': 'execution_start', 'data': {'prompt_id': '453484bb-1749-4fe3-9f2c-31664b8c3aec', 'timestamp': 1747821408300}}
                # {'type': 'execution_cached', 'data': {'nodes': [], 'prompt_id': '453484bb-1749-4fe3-9f2c-31664b8c3aec', 'timestamp': 1747821408304}}
                # {'type': 'executing', 'data': {'node': '4', 'display_node': '4', 'prompt_id': '453484bb-1749-4fe3-9f2c-31664b8c3aec'}}
                # {'type': 'progress', 'data': {'value': 1, 'max': 20, 'prompt_id': '453484bb-1749-4fe3-9f2c-31664b8c3aec', 'node': '3'}}
                # {'type': 'executing', 'data': {'node': None, 'prompt_id': '453484bb-1749-4fe3-9f2c-31664b8c3aec'}}
                # 'type': 'serverless_api', 'data': ... }
                print(data)

                # The type of the final result is serverless_api
                if data["type"] == "serverless_api":
                    return data


with open("./api.json", "r", encoding="utf-8") as f:
    result = txt2img(json.loads(f.read()))
    images = result["data"]["results"]
    for image in images:
        # The output will be serverless-api-output/b74f33c0-69ba-4e4b-b584-6700890b7f51.png
        print(image["output"]["oss"]["object"])

Asynchronous image generation

To avoid blocking the calling thread, use the built-in asynchronous invocation feature of Function Compute and poll for the result using the status API. This feature is provided by Function Compute. For more information, see Invoke a function.

from time import sleep
import requests
import json
import uuid

# Enter your public request address
endpoint = "https://xxx.xxx.fcapp.run"


def txt2img(prompt):
    task_id = str(uuid.uuid4())

    requests.post(
        f"{endpoint}/api/serverless/run?output_oss=true",
        json=prompt,
        headers={"X-Fc-Invocation-Type": "Async", "X-Fc-Trace-Id": task_id},
    )

    while True:
        resp = requests.get(
            f"{endpoint}/api/serverless/status?task_id={task_id}",
        )
        statusList = resp.json()
        # All intermediate states of the current image generation task are output as an array
        print(statusList)

        if len(statusList) > 0:
            if statusList[-1]["type"] == "serverless_api":
                return statusList[-1]

        sleep(1)


with open("./api.json", "r", encoding="utf-8") as f:
    result = txt2img(json.loads(f.read()))
    images = result["data"]["results"]
    for image in images:
        # The output will be serverless-api-output/b74f33c0-69ba-4e4b-b584-6700890b7f51.png
        print(image["output"]["oss"]["object"])

WebSocket image generation

If you have already integrated the native WebSocket API and use WebSocket to track image generation progress, you can adopt the WebSocket image generation operation to integrate the ComfyUI Serverless API with minimal changes.

import json
import websocket  # pip install websocket-client

# Enter your public request address
# Note: Use the ws or wss protocol
endpoint = "wss://xxx.xxx.fcapp.run"


def txt2img(prompt):
    result = {}

    def on_open(ws):
        ws.send(json.dumps(prompt))

    def on_message(ws, msg):
        # As the image generation progresses, the current node status is output
        data = json.loads(msg)
        print(data)

        if data["type"] == "serverless_api":
            nonlocal result
            result = data
            ws.close()

    ws = websocket.WebSocketApp(
        f"{endpoint}/api/serverless/ws?output_oss=true",
        on_open=on_open,
        on_message=on_message,
    )

    ws.run_forever()

    return result


with open("./api.json", "r", encoding="utf-8") as f:
    result = txt2img(json.loads(f.read()))
    images = result["data"]["results"]
    for image in images:
        # The output will be serverless-api-output/b74f33c0-69ba-4e4b-b584-6700890b7f51.png
        print(image["output"]["oss"]["object"])