ComfyUI API Python: वर्कफ़्लो चलाएँ, एंडपॉइंट और उदाहरण

ComfyUI नोड ग्राफ़ के लिए एक ड्रॉइंग बोर्ड जैसा दिखता है, लेकिन कैनवस के नीचे यह एक सामान्य HTTP सर्वर है। ब्राउज़र में आप जो भी बटन दबाते हैं, वह एक एंडपॉइंट को कॉल करता है, और एक Python स्क्रिप्ट भी उन्हीं एंडपॉइंट्स को कॉल कर सकती है। Python के साथ ComfyUI API का पूरा विचार यही है: वर्कफ़्लो को JSON के रूप में एक्सपोर्ट करें, दो-तीन वैल्यू बदलें, उसे /prompt पर POST करें, फिर तैयार इमेज इकट्ठा करें। कोई ब्राउज़र टैब नहीं, कोई क्लिक नहीं, कोई निगरानी नहीं। यह लेख असली एंडपॉइंट्स, लाइव प्रोग्रेस के लिए एक WebSocket लिसनर और काम करने वाले उदाहरण दिखाता है, जिन्हें आप किसी फ़ाइल में चिपकाकर अपनी मशीन पर चला सकते हैं।

ComfyUI की स्क्रिप्टिंग क्यों करें

एक इमेज हाथ से बनाना ठीक है। लेकिन दो सौ प्रोडक्ट शॉट्स बनाना, हर रात थंबनेल का जॉब चलाना, या ग्राहकों को अपने ऐप में बटन दबाकर इमेज बनाने देना, यह अलग बात है, और कैनवस इनमें से कुछ भी नहीं कर सकता। एक headless ComfyUI सर्वर यह कर सकता है, और वहाँ तक पहुँचने का सबसे छोटा रास्ता Python है। एक अतिरिक्त फ़ायदा यह भी है कि आपके प्रॉम्प्ट, सीड और सेटिंग्स स्क्रीनशॉट वाले फ़ोल्डर के बजाय एक Git रिपॉज़िटरी में रहते हैं।

API तीन स्थितियों में उपयोगी साबित होता है:

• बैच वर्क: सैकड़ों प्रॉम्प्ट, एक टेम्पलेट, और शून्य मैन्युअल क्लिक।
• प्रोडक्ट: आपका अपना ऐप अनुरोध भेजता है और इमेज वापस पाता है।
• ऑटोमेशन: एक cron जॉब, एक चैट बॉट या एक CI स्टेप, जो तय समय पर एसेट्स रेंडर करता है।

सर्वर कौन-से एंडपॉइंट दिखाता है

ComfyUI को हमेशा की तरह शुरू करें (python main.py) और वह 127.0.0.1:8188 पर सुनने लगता है। दूसरी मशीनों से कनेक्शन स्वीकार करने के लिए --listen 0.0.0.0 जोड़ें और पोर्ट बदलने के लिए --port। ये वे एंडपॉइंट्स हैं जिन्हें आप सबसे ज़्यादा बार इस्तेमाल करेंगे:

लय कभी नहीं बदलती: क्यू, इंतज़ार, फ़ेच। आप एक ग्राफ़ POST करते हैं, इंतज़ार करते हैं (पोलिंग से या WebSocket पर सुनकर), और ग्राफ़ ने जो बनाया उसे डाउनलोड करते हैं।

वर्कफ़्लो को API फ़ॉर्मेट में एक्सपोर्ट करें

पहले कैनवस पर ग्राफ़ बनाएँ और उसे टेस्ट करें। जब वह इमेज बनाए जो आप चाहते हैं, तब उसे एक्सपोर्ट करें। आपकी स्क्रिप्ट सामान्य वर्कफ़्लो फ़ाइल नहीं चला सकती, क्योंकि उस फ़ॉर्मेट में कैनवस की पोज़िशन, रंग और विजेट लेआउट सेव होते हैं। स्क्रिप्ट को हल्का वर्ज़न चाहिए, जिसमें हर नोड सिर्फ़ अपनी क्लास और इनपुट्स तक सीमित हो।

API फ़ॉर्मेट बनाम सामान्य JSON

आज के फ़्रंटएंड में Workflow मेनू खोलें और Export (API) चुनें। पुराने बिल्ड पर सेटिंग्स में Dev mode options चालू करें और Save (API Format) बटन इस्तेमाल करें। नतीजे को अपनी स्क्रिप्ट के बगल में workflow_api.json नाम से सेव करें।

💡 टिप: दोनों फ़ाइलें रखें। सामान्य JSON एडिट करने के लिए कैनवस पर वापस खुलती है, जबकि API JSON वह है जो आपका कोड भेजता है।

एक्सपोर्ट किए गए JSON की बनावट

फ़ाइल खोलें तो आपको एक फ़्लैट डिक्शनरी दिखेगी। हर एंट्री का नाम एक नोड ID (एक स्ट्रिंग) पर रखा गया है, और उसकी वैल्यू में एक class_type के साथ नोड के inputs होते हैं:

{
  "3": {
    "class_type": "KSampler",
    "inputs": {
      "seed": 421337,
      "steps": 20,
      "cfg": 1.0,
      "sampler_name": "euler",
      "scheduler": "simple",
      "denoise": 1.0,
      "model": ["4", 0],
      "positive": ["6", 0],
      "negative": ["7", 0],
      "latent_image": ["5", 0]
    }
  },
  "4": {
    "class_type": "CheckpointLoaderSimple",
    "inputs": { "ckpt_name": "flux1-dev-fp8.safetensors" }
  },
  "6": {
    "class_type": "CLIPTextEncode",
    "inputs": { "text": "a lighthouse at dawn", "clip": ["4", 1] },
    "_meta": { "title": "Positive Prompt" }
  }
}

प्रॉम्प्ट कॉपी करें

यह उदाहरण एक Flux Dev चेकपॉइंट मानकर चलता है, इसीलिए cfg 1.0 पर रखा गया है। Stable Diffusion 3.5 Large जैसे चेकपॉइंट आम तौर पर ज़्यादा वैल्यू चाहते हैं, अक्सर 4 से 8 के बीच, इसलिए नंबर किसी ट्यूटोरियल से नहीं, अपने ही एक्सपोर्ट से कॉपी करें।

दो बातें मायने रखती हैं। seed और steps जैसी सादी वैल्यू वे नॉब हैं जिन्हें आप Python से बदलते हैं। ["4", 0] जैसी वैल्यू लिंक हैं: पहला आइटम स्रोत नोड की ID है, दूसरा वह आउटपुट स्लॉट है जिसे पढ़ना है। जब तक आप जानबूझकर ग्राफ़ की वायरिंग नहीं बदल रहे, इन्हें अकेला छोड़ें।

💡 टिप: एक्सपोर्ट से पहले कैनवस पर अपने प्रॉम्प्ट नोड्स का नाम बदलें ("Positive Prompt", "Negative Prompt")। यह नाम _meta.title में जाता है, और आपका कोड नोड्स को नाज़ुक नंबर के बजाय टाइटल से खोज सकता है।

आपकी पहली Python कॉल

इस लेख की हर चीज़ के लिए दो पैकेज काफ़ी हैं: pip install requests websocket-client। एक्सपोर्ट को workflow_api.json नाम से सेव करें, ComfyUI शुरू करें, और स्निपेट्स को क्रम से चलाएँ।

इंस्टॉल करें और प्रॉम्प्ट क्यू में डालें

import json
import requests

SERVER = "http://127.0.0.1:8188"

with open("workflow_api.json", "r", encoding="utf-8") as f:
    workflow = json.load(f)

# "6" is the positive CLIPTextEncode, "3" is the KSampler
workflow["6"]["inputs"]["text"] = "a lighthouse at dawn, 35mm photo, film grain"
workflow["3"]["inputs"]["seed"] = 421337

response = requests.post(f"{SERVER}/prompt", json={"prompt": workflow})
response.raise_for_status()
prompt_id = response.json()["prompt_id"]
print("Queued:", prompt_id)

प्रॉम्प्ट कॉपी करें

ComfyUI एक JSON बॉडी लौटाता है, जिसमें prompt_id और number होते हैं, यानी क्यू में स्थिति। इस समय तक कुछ भी रेंडर नहीं हुआ है। प्रॉम्प्ट को सिर्फ़ स्वीकार किया गया है। ID संभालकर रखें, क्योंकि हर बाद की कॉल को उसकी ज़रूरत होगी।

History एंडपॉइंट को पोल करें

यह जानने का सबसे सरल तरीका कि प्रॉम्प्ट पूरा हुआ या नहीं, history एंडपॉइंट से तब तक पूछते रहना है जब तक वह जवाब न दे। जब तक रन चल रहा है, /history/{prompt_id} एक खाली ऑब्जेक्ट लौटाता है।

import time

def wait_for_outputs(prompt_id, timeout=300):
    started = time.time()
    while time.time() - started < timeout:
        history = requests.get(f"{SERVER}/history/{prompt_id}").json()
        if prompt_id in history:
            return history[prompt_id]["outputs"]
        time.sleep(1)
    raise TimeoutError(f"Prompt {prompt_id} took longer than {timeout}s")

प्रॉम्प्ट कॉपी करें

outputs डिक्शनरी नोड ID से इंडेक्स होती है। हर SaveImage नोड images नाम की एक लिस्ट बताता है, और हर इमेज एक छोटी डिक्शनरी होती है जिसमें filename, subfolder और type होते हैं।

तैयार इमेज डाउनलोड करें

import os

def download_images(outputs, folder="renders"):
    os.makedirs(folder, exist_ok=True)
    saved = []
    for node_id, node_output in outputs.items():
        for image in node_output.get("images", []):
            if image["type"] != "output":
                continue  # skip PreviewImage temp files
            data = requests.get(f"{SERVER}/view", params=image).content
            path = os.path.join(folder, image["filename"])
            with open(path, "wb") as f:
                f.write(data)
            saved.append(path)
    return saved

print(download_images(wait_for_outputs(prompt_id)))

प्रॉम्प्ट कॉपी करें

इमेज डिक्शनरी में पहले से वे तीन पैरामीटर होते हैं जिनकी /view को ज़रूरत है, इसलिए उसे सीधे क्वेरी स्ट्रिंग के रूप में दिया जा सकता है। SaveImage नोड type: "output" बताते हैं, जबकि PreviewImage नोड temp बताते हैं, और लूप इसी आधार पर फ़िल्टर करता है।

WebSocket पर लाइव प्रोग्रेस

पोलिंग काम करती है, पर वह कॉल बर्बाद करती है और आख़िर तक कुछ नहीं बताती। ComfyUI WebSocket प्रोटोकॉल भी इस्तेमाल करता है, जो आपको लाइव फ़ीड देता है: क्यू में बदलाव, अभी चल रहा नोड, और हर sampler step का काउंटर। वेब ऐप में यही प्रोग्रेस बार को चलाता है।

क्लाइंट ID के साथ कनेक्ट करें

एक UUID एक बार बनाएँ और उसे दो जगह इस्तेमाल करें: सॉकेट की clientId क्वेरी स्ट्रिंग में, और अपनी /prompt रिक्वेस्ट के client_id फ़ील्ड में। ComfyUI किसी प्रॉम्प्ट के इवेंट्स सिर्फ़ उसी क्लाइंट को भेजता है जिसने उसे क्यू में डाला था। ID मेल न खाएँ तो आपका सॉकेट चुप रहेगा।

import json
import uuid
import requests
import websocket  # pip install websocket-client

HOST = "127.0.0.1:8188"
CLIENT_ID = str(uuid.uuid4())

def run_with_progress(workflow):
    ws = websocket.WebSocket()
    ws.connect(f"ws://{HOST}/ws?clientId={CLIENT_ID}")

    payload = {"prompt": workflow, "client_id": CLIENT_ID}
    r = requests.post(f"http://{HOST}/prompt", json=payload)
    r.raise_for_status()
    prompt_id = r.json()["prompt_id"]

    while True:
        message = ws.recv()
        if isinstance(message, bytes):
            continue  # binary frames are preview thumbnails
        event = json.loads(message)
        kind, data = event["type"], event["data"]

        if kind == "progress":
            print(f"step {data['value']}/{data['max']}")
        elif kind == "execution_error":
            raise RuntimeError(data.get("exception_message", "node failed"))
        elif data.get("prompt_id") == prompt_id and (
            kind == "execution_success"
            or (kind == "executing" and data["node"] is None)
        ):
            break

    ws.close()
    history = requests.get(f"http://{HOST}/history/{prompt_id}").json()
    return history[prompt_id]["outputs"]

प्रॉम्प्ट कॉपी करें

बाइनरी फ़्रेम्स में sampler के काम करते समय प्रीव्यू थंबनेल आते हैं, इसलिए लूप टेक्स्ट न होने वाली हर चीज़ छोड़ देता है। अगर आप अपने इंटरफ़ेस के भीतर लाइव प्रीव्यू चाहते हैं, तो उन फ़्रेम्स को छोड़ने के बजाय डिकोड करें।

जो मैसेज आप पाएँगे

executing मैसेज, जिसमें node को null पर सेट है, रन खत्म होने का पारंपरिक संकेत है। नए बिल्ड execution_success भी जोड़ते हैं, और दोनों को संभालने से आपकी स्क्रिप्ट अलग-अलग वर्ज़न पर चलती रहती है।

एक क्लाइंट क्लास में समेटें

पहली जाँच के लिए अलग-अलग फ़ंक्शन ठीक हैं। लेकिन जो चीज़ एक से ज़्यादा बार चलेगी, उसके लिए एक छोटी क्लास चाहिए जो होस्ट, क्लाइंट ID और वे ऑपरेशन रखे जिन्हें आप बार-बार दोहराते हैं।

import time
import uuid
import requests

class ComfyClient:
    def __init__(self, host="127.0.0.1:8188"):
        self.host = host
        self.client_id = str(uuid.uuid4())

    def queue(self, workflow):
        r = requests.post(
            f"http://{self.host}/prompt",
            json={"prompt": workflow, "client_id": self.client_id},
        )
        if r.status_code != 200:
            raise RuntimeError(r.text)  # includes node_errors
        return r.json()["prompt_id"]

    def result(self, prompt_id, timeout=300):
        deadline = time.time() + timeout
        while time.time() < deadline:
            history = requests.get(f"http://{self.host}/history/{prompt_id}").json()
            if prompt_id in history:
                return history[prompt_id]
            time.sleep(1)
        raise TimeoutError(prompt_id)

    def fetch(self, image):
        r = requests.get(f"http://{self.host}/view", params=image)
        r.raise_for_status()
        return r.content

    def upload(self, path):
        with open(path, "rb") as f:
            r = requests.post(
                f"http://{self.host}/upload/image",
                files={"image": f},
                data={"overwrite": "true"},
            )
        r.raise_for_status()
        return r.json()["name"]

प्रॉम्प्ट कॉपी करें

प्रॉम्प्ट और सीड सुरक्षित तरीके से बदलें

असली प्रोजेक्ट में "6" जैसे नोड ID कभी हार्ड-कोड न करें। ग्राफ़ दोबारा एक्सपोर्ट करने पर नंबर बदल सकते हैं। इसके बजाय क्लास और टाइटल से नोड खोजें, और हमेशा टेम्पलेट की कॉपी एडिट करें, ताकि एक जॉब की चीज़ें अगले जॉब में न जाएँ।

import copy
import json
import random

def find_node(workflow, class_type, title=None):
    for node_id, node in workflow.items():
        if node["class_type"] != class_type:
            continue
        if title is None or node.get("_meta", {}).get("title") == title:
            return node_id
    raise LookupError(f"{class_type} {title or ''} not found")

def build(template, prompt, seed=None):
    wf = copy.deepcopy(template)
    wf[find_node(wf, "CLIPTextEncode", "Positive Prompt")]["inputs"]["text"] = prompt
    wf[find_node(wf, "KSampler")]["inputs"]["seed"] = (
        seed if seed is not None else random.randint(0, 2**32 - 1)
    )
    return wf

template = json.load(open("workflow_api.json", encoding="utf-8"))
client = ComfyClient()

prompts = [
    "ceramic teapot on a linen cloth, soft window light",
    "walnut desk with a fountain pen, low morning sun",
    "leather boots on wet cobblestones, overcast sky",
]

ids = [client.queue(build(template, p)) for p in prompts]  # queue everything first
for pid in ids:
    entry = client.result(pid)
    for out in entry["outputs"].values():
        for image in out.get("images", []):
            with open(image["filename"], "wb") as f:
                f.write(client.fetch(image))

प्रॉम्प्ट कॉपी करें

पहले सब कुछ क्यू में डालें, फिर इकट्ठा करें। ComfyUI प्रॉम्प्ट्स को उसी क्रम में, एक-एक करके चलाता है जिसमें वे आए थे, इसलिए आपकी स्क्रिप्ट फ़ाइल डाउनलोड करते समय GPU खाली नहीं बैठता।

💡 टिप: तीन के बजाय 200 प्रॉम्प्ट चाहिए? Claude Sonnet 5 या Gemini 3.5 Flash जैसे लैंग्वेज मॉडल से उन्हें JSON लिस्ट के रूप में लिखवाएँ, फिर वही लिस्ट ऊपर वाले लूप में सीधे डाल दें।

इमेज एडिट के लिए इमेज अपलोड करें

इमेज-टू-इमेज, इनपेंटिंग और ControlNet ग्राफ़ एक LoadImage नोड से शुरू होते हैं। यह नोड ComfyUI के इनपुट फ़ोल्डर से पढ़ता है, इसलिए पहले फ़ाइल अपलोड करें और नोड को लौटाए गए नाम की ओर इंगित करें।

name = client.upload("portrait.png")
wf = copy.deepcopy(template)
wf[find_node(wf, "LoadImage")]["inputs"]["image"] = name
pid = client.queue(wf)

प्रॉम्प्ट कॉपी करें

यहीं स्क्रिप्टिंग विज़ुअल इफ़ेक्ट्स के काम के करीब पहुँचती है। ऑब्जेक्ट हटाना, बैकग्राउंड बदलना और रीलाइटिंग, सब एक ही लूप हैं: एक सोर्स इमेज अपलोड करें, मास्क और प्रॉम्प्ट सेट करें, क्यू में डालें, फ़ेच करें। इसे एक फ़ंक्शन में लपेट दें, तो 500 फ़ोटो वाला फ़ोल्डर एक कमांड बन जाता है।

प्रोडक्शन की गलतियाँ जिनसे बचें

आपके लैपटॉप पर चलने वाली स्क्रिप्ट्स, बिना निगरानी के चलने पर, अनुमानित तरीकों से टूटती हैं। तीन समस्याएँ ज़्यादातर सपोर्ट सवालों की जड़ होती हैं।

कैश्ड नतीजे तुरंत लौट आते हैं

ComfyUI नोड परिणाम उनके इनपुट्स के आधार पर कैश करता है। एक ही ग्राफ़ को दो बार क्यू में डालें तो दूसरा रन कुछ भी नहीं चलाता, इसलिए आपको मिलीसेकंड में वही इमेज वापस मिल जाती है। "randomize seed after each run" विकल्प सिर्फ़ ब्राउज़र इंटरफ़ेस में मौजूद है। API JSON में एक तय नंबर रहता है, इसलिए जब भी आपको नई इमेज चाहिए, आपके कोड को नया सीड चुनना होगा।

node_errors को सही तरीके से पढ़ें

जब वैलिडेशन फ़ेल होता है, तो /prompt HTTP 400 के साथ जवाब देता है, और बॉडी में error और node_errors होते हैं। दूसरा फ़ील्ड ठीक उस नोड ID और इनपुट का नाम बताता है जिसमें गड़बड़ी है, जैसे कोई चेकपॉइंट फ़ाइल नाम जो इस मशीन पर इंस्टॉल नहीं है। सिर्फ़ स्टेटस कोड नहीं, पूरी बॉडी प्रिंट करें। यह भी याद रखें कि प्रॉम्प्ट वैलिडेशन पास कर सकता है और फिर भी एक्ज़ीक्यूशन के दौरान फ़ेल हो सकता है। ऐसे में history एंट्री में status_str: "error" दिखेगा।

पोर्ट 8188 कभी खुला न छोड़ें

ComfyUI बिना लॉगिन के आता है। जो भी उस पोर्ट तक पहुँच सकता है, वह जॉब क्यू में डाल सकता है, आपका आउटपुट फ़ोल्डर पढ़ सकता है और /object_info कॉल कर सकता है। कस्टम नोड सादे Python हैं और आपके यूज़र की अनुमतियों के साथ चलते हैं। 127.0.0.1 पर बाइंड करें, या सर्वर को ऑथेंटिकेशन वाले reverse proxy या VPN के पीछे रखें। अगर किसी दूसरे ओरिजिन की ब्राउज़र ऐप को इसे कॉल करना है, तो wildcard के बजाय --enable-cors-header में वही एक ओरिजिन दें।

💡 टिप: कई अलग-अलग चेकपॉइंट के बाद VRAM कम पड़ रहा है? बैच के बीच {"unload_models": true, "free_memory": true} को /free पर POST करें, ताकि सर्वर को दोबारा शुरू किए बिना मेमोरी खाली हो जाए।

Picasso IA के साथ सर्वर छोड़ें

हर प्रोजेक्ट को GPU बॉक्स, Python एनवायरनमेंट और निगरानी के लिए क्यू की ज़रूरत नहीं होती। अगर आपका लक्ष्य सिर्फ़ टेक्स्ट या रेफ़रेंस फ़ोटो से अच्छी इमेज पाना है, तो Picasso IA ब्राउज़र में तुलनीय मॉडल चलाता है। आम ComfyUI कामों के हिसाब से मॉडल इस तरह मेल खाते हैं:

छह चरणों में जनरेट करें

Flux 2 Pro के साथ पूरी प्रक्रिया यहाँ है। यह वह मॉडल है जो ComfyUI के रेफ़रेंस-इमेज वर्कफ़्लो के सबसे करीब आता है:

1. Picasso IA पर Flux 2 Pro पेज खोलें।
2. अपना प्रॉम्प्ट लिखें। सब्जेक्ट, रोशनी और लेंस का नाम बताएँ, ठीक वैसे ही जैसे आप ComfyUI के टेक्स्ट नोड में लिखते हैं।
3. एक आस्पेक्ट रेशियो चुनें। डिफ़ॉल्ट 1:1 है, 16:9 बैनर के लिए ठीक रहता है, और match_input_image अपलोड की गई फ़ोटो का आकार बनाए रखता है।
4. एक रिज़ॉल्यूशन चुनें। डिफ़ॉल्ट 1 MP है, और मॉडल 4 MP तक स्वीकार करता है, हालाँकि 2 MP या उससे कम की सलाह दी जाती है।
5. अगर आप चाहते हैं कि नतीजा किसी स्टाइल, चेहरे या प्रोडक्ट शॉट का पालन करे, तो अधिकतम 8 इनपुट इमेज जोड़ें।
6. आउटपुट फ़ॉर्मेट (WebP, JPG या PNG) सेट करें, फिर जनरेट दबाएँ। वही नतीजा दोबारा बनाने के लिए बाद में सीड दोबारा इस्तेमाल करें।

💡 टिप: ऊपर आपने जो आदतें बनाई हैं, वे सीधे काम आएँगी। दोहराए जा सकने वाले नतीजों के लिए तय सीड, हर रन में एक ही बदलाव, और रोशनी व लेंस का नाम बताने वाले छोटे प्रॉम्प्ट, ये दोनों प्लेटफ़ॉर्म पर एक जैसे काम करते हैं।

आज ही अपनी इमेज बनाएँ

अब आपके पास पूरा चक्र है: ग्राफ़ एक्सपोर्ट करें, उसे क्यू में डालें, सॉकेट पर सुनें, फ़ाइलें फ़ेच करें। आज रात पहला स्निपेट चलाएँ, तो चाय ठंडी होने से पहले आपकी डिस्क पर एक इमेज होगी। फिर क्लाइंट क्लास को और कसें, सीड वाला लॉजिक जोड़ें, और जब आप कुछ और कर रहे हों तब बैच को चलने दें।

और अगर आप सेटअप छोड़ना चाहते हैं, तो Picasso IA खोलें, Flux Dev या Flux 2 Pro चुनें, और जो पहला प्रॉम्प्ट मन में आए वह टाइप करें। एक सेटिंग बदलें, दोबारा जनरेट करें, और तुलना करें। पाँच मिनट के प्रयोग आपको प्रॉम्प्ट, सीड और आस्पेक्ट रेशियो के बारे में किसी भी मात्रा की पढ़ाई से ज़्यादा बता देंगे।