ComfyUI API calls

Export the workflow API as a JSON file

Before you make API calls, build and debug your workflow in the ComfyUI WebUI. Ensure that the workflow can generate images successfully. After debugging, in the ComfyUI interface, click the Workflow > Export (API) menu item. Your browser then downloads a JSON file that contains the workflow definition.

This 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": "KSampler"
    }
  },
  "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 Decode"
    }
  },
  "9": {
    "inputs": {
      "filename_prefix": "ComfyUI",
      "images": [
        "8",
        0
      ]
    },
    "class_type": "SaveImage",
    "_meta": {
      "title": "Save Image"
    }
  }
}

Publish the API

Once the workflow JSON file is ready, configure an API access endpoint for your ComfyUI function by switching to the API Call tab and clicking Publish API.

Modify GPU specifications and elastic policies

When you configure the ComfyUI API operation, set the resource specifications for the function based on the expected call load and performance requirements. Consider the following parameters:

• GPU specifications: Select GPU-accelerated instances with different card types and configurations to process API call requests. The computing complexity and resource consumption of ComfyUI workflows vary significantly. We recommend that you test your workflow to evaluate the performance of different GPU specifications based on task processing time and cost. Then, select the optimal configuration.

• Elastic policy:

  • Pay-as-you-go mode: This is a pay-as-you-go billing method. No computing fees are incurred when there are no requests. In sparse invocation scenarios, cold starts may occur, which can slow down the response to the first request.

  • Express mode: This mode caches ComfyUI in a provisioned snapshot, which incurs only minimal snapshot storage fees. This method effectively avoids cold starts and significantly improves the response speed for low-frequency calls. If the number of required instances exceeds the number of provisioned snapshots, on-demand instances may still be created. In this case, some requests may experience a cold start.

After you publish the API, the platform automatically generates an API address for external calls. You can refer to the API call documentation on the page and use the exported JSON file to construct an API request for your AI image generation service.

HTTP image generation

WebSocket image generation

The logic of this operation is the same as that of the HTTP mode. Input parameters are passed using websocket.send().

Get status

This operation retrieves the status of an image generation task. Due to the stateless nature of Function as a Service (FaaS), you must configure storage to ensure that status information is correctly persisted.

To save the status 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 not the generation progress, you can 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 is serverless-api-output/b74f33c0-69ba-4e4b-b584-6700890b7f51.png
        print(image["output"]["oss"]["object"])

Streaming image generation

To receive the image generation progress in real time, you can 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():
            # 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
                # The following are some possible output lines
                # {'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 is serverless-api-output/b74f33c0-69ba-4e4b-b584-6700890b7f51.png
        print(image["output"]["oss"]["object"])

Asynchronous image generation

If you do not want the call to be blocked, use the asynchronous invocation feature of Function Compute. Then, poll the Get Status API operation to retrieve the result. The asynchronous invocation feature is provided by Function Compute. For more information, see InvokeFunction.

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 is 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 receive the image generation progress, you can use the WebSocket image generation operation. This lets you use 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 is serverless-api-output/b74f33c0-69ba-4e4b-b584-6700890b7f51.png
        print(image["output"]["oss"]["object"])

What if I cannot find my workflow?

If you have generated an image, find it in the history queue in the menu on the left. Right-click the image and select Load Workflow to restore the workflow.