Comfy SDKs: Python and TypeScript Clients for ComfyUI

pip install comfy-sdk

npm i @comfyorg/sdk

from comfy_sdk import Comfy

# Comfy Cloud
client = Comfy(api_key="comfyui-...")

wf = client.workflows.from_file("workflow_api.json")

asset = client.assets.from_file("photo.png")
wf.set_input("10", "image", asset)

job = client.run(wf)
for output in job.get_outputs("9"):
    output.to_file(output.name)

import { Comfy } from "@comfyorg/sdk";

// Comfy Cloud
const client = new Comfy({ apiKey: "comfyui-..." });

const wf = await client.workflows.fromFile("workflow_api.json");

const asset = client.assets.fromFile("photo.png");
wf.setInput("10", "image", asset);

const job = await client.run(wf);
await job.getOutputs("9")[0].toFile("out.png");

client = Comfy(api_key="comfyui-...")

const client = new Comfy({ apiKey: "comfyui-..." });

import uuid
from comfy_sdk import IdempotencyKeyReuse

# Both values belong in your own store, keyed by whatever the request means to
# you. `key` is minted once, on the first attempt; `job_id` is filled in as soon
# as a submit returns.
state = load_submission_state()  # {"key": ..., "job_id": ...} or {}
key = state.get("key") or str(uuid.uuid4())
save_submission_state(key=key)

try:
    job = client.submit(wf, idempotency_key=key)
    save_submission_state(key=key, job_id=job.id)
except IdempotencyKeyReuse:
    # An earlier attempt under this key already reached submission, so a job
    # may exist. Do not resubmit: go and find it.
    job_id = state.get("job_id")
    if job_id is None:
        raise  # nothing recorded to look up; this needs a human
    job = client.jobs.get(job_id)

import { IdempotencyKeyReuse } from "@comfyorg/sdk";

// Both values belong in your own store, keyed by whatever the request means to
// you. `key` is minted once, on the first attempt; `jobId` is filled in as soon
// as a submit returns.
const state = await loadSubmissionState(); // { key?, jobId? }
const key = state.key ?? crypto.randomUUID();
await saveSubmissionState({ key });

let job;
try {
  job = await client.submit(wf, { idempotencyKey: key });
  await saveSubmissionState({ key, jobId: job.id });
} catch (err) {
  // An earlier attempt under this key already reached submission, so a job
  // may exist. Do not resubmit: go and find it.
  if (!(err instanceof IdempotencyKeyReuse) || !state.jobId) throw err;
  job = await client.jobs.get(state.jobId);
}

from comfy_sdk import Progress, Preview, OutputReady, StatusChange

job = client.submit(wf)

for event in job.events():
    match event:
        case Progress() as p:
            print(f"{p.value:.0%} {p.message}")
        case Preview() as pv:
            image = pv.to_pil()
        case OutputReady() as o:
            o.output.to_file(f"partial/{o.output.name}")
        case StatusChange(status="succeeded"):
            break

result = job.result()

const job = await client.submit(wf);

// The label is required: a bare `break` inside a switch leaves the switch,
// not the loop.
eventLoop: for await (const event of job.events()) {
  switch (event.kind) {
    case "progress":
      console.log(event.value);
      break;
    case "outputReady":
      await event.output.toFile(`${event.output.name}`);
      break;
    case "statusChange":
      if (event.status === "succeeded") break eventLoop;
  }
}

output = job.outputs[0]
output.job_id          # the job that produced this file

const output = job.outputs[0];
output.jobId; // the job that produced this file

wf = job.get_workflow()

if wf.format == "save":
    ...  # the workflow as authored, canvas layout and Note nodes intact
else:
    ...  # the executed API-format graph

const wf = await job.getWorkflow();

if (wf.format === "save") {
  // the workflow as authored, canvas layout and Note nodes intact
} else {
  // the executed API-format graph
}

job = client.submit(wf, metadata={"client": "acme", "project": "spring"})
job.metadata  # {"client": "acme", "project": "spring"}

const job = await client.submit(wf, {
  metadata: { client: "acme", project: "spring" },
});
job.metadata; // { client: "acme", project: "spring" }

for job in client.list_jobs(metadata={"client": "acme"}):
    print(job.id, job.status)

for await (const job of client.listJobs({ metadata: { client: "acme" } })) {
  console.log(job.id, job.status);
}