BranchesTags

Repository files navigation

ComfyAPI

A friendly FastAPI-based service that provides REST API and WebSocket interfaces to ComfyUI, making it easy to run AI image generation workflows remotely.

What's This All About?

ComfyAPI sits between your applications and ComfyUI, handling the communication details so you can focus on creating images. It manages process lifecycles and connections behind the scenes.

ComfyUI has powerful capabilities, but its communication protocols can be complex. This project bridges that gap by providing a simple standardize REST interface that applications can use. Whether you're working with web apps, mobile services, or automation scripts, ComfyAPI simplifies the integration.

How It Works

ComfyAPI connects your applications to ComfyUI through several components:

  • API Layer - Offers a structured REST interface for applications
  • Protocol Bridge - Handles conversion between HTTP requests and ComfyUI's WebSocket messages
  • Connection Management - Maintains the websocket connections with proper lifecycle handling
  • Custom Nodes - Extends ComfyUI with specialized input/output nodes for API integration
  • Input Processing - Validates and formats inputs for ComfyUI workflows
  • Output Streaming - Delivers results back through websockets in real-time

Built on FastAPI's asynchronous foundation and equipped with specialized connection managers, the system can handle numerous concurrent requests, making it suitable for multi-user environments or high-volume processing scenarios. This abstraction lets you work with ComfyUI through straightforward API calls without worrying about its internal implementation details.

Features ✨

  • REST API - Structured endpoints for workflow execution
  • WebSocket Interface - Real-time updates during image generation
  • Connection Handling - Automatic management of client-backend connections
  • Workflow Analysis - Automatic extraction of inputs and outputs from workflows
  • API Key Auth - Simple security for your endpoints
  • Auto-Cleanup - Background handling of idle connections

Project Structure 📦

├── src/
│ ├── api/ # API endpoints and routers
│ ├── comfyui/ # ComfyUI integration code
│ ├── data/ # Data models and schemas
│ └── utils/ # Helper utilities
├── workflows/ # Example workflow definitions
├── custom_nodes/ # ComfyUI custom input/output nodes
├── .env # Configuration settings
└── .env.sample # Template configuration file

Requirements 🏊

  • Python 3.9+
  • ComfyUI installed and ready to go
  • Access to wherever ComfyUI lives on your system

Getting Started 🚀

  1. Grab the code:

    git clone https://github.com/piewared/ComfyAPI.git
cd ComfyAPI

  2. Set up your Python virtual environment:

    python -m venv .venv
source .venv/bin/activate # On Windows: .venv\Scripts\activate

  3. Install python dependencies

    pip install -r requirements.txt

  4. Copy the provided .env template:

    cp .env.sample .env

  5. Set the path to your ComfyUI installation and your API key in the .env file:

    COMFYUI_BASE_PATH=/path/to/ComfyUI
APP_API_KEY=your_secure_api_key

    The API key is used to authenticate requests to the API. It should be kept secret and only shared with trusted applications.

Fire It Up! 🔥

uvicorn src.api.app:app --host 127.0.0.1 --port 8000 --reload

How to Use This Thing 🛠️

Creating ComfyAPI Workflows in ComfyUI

  1. Install the ComfyUI custom nodes
    • Copy the custom_nodes/ComfyAPI folder to your ComfyUI installation's custom_nodes directory
  2. Create a workflow in ComfyUI:
    • Add nodes and connections as usual to build your image generation process
    • Use the ComfyAPI input and output nodes to define your workflow's inputs and outputs

Knocking on the Door (Authentication)

Don't forget your unique API key! Add this to your request headers:

X-API-Key: APP_API_KEY

Playing with Workflows

  1. See what workflows are available:

    GET /workflows/

  2. Look under the hood of a workflow to get its requested inputs:

    GET /workflows/{workflow_id}

  3. Get yourself a websocket:

    • Use your favorite websocket client to connect to /ws/register with your API key
    • You'll get a response containing a connection ID to use in the next step:
    {"websocket_cid":"7e51a24f2cbf4873b205a414aab33897"}

  4. Populate the input nodes and make the magic happen:

    POST /workflows/{workflow_id}/queue

    With this in the body:

    {
"websocket_cid": "your_websocket_cid",
"inputs": [
{
"node_id": "node_1",
"value": "https://example.com/image.jpg"
}
]
}

  5. Sit back and enjoy the show: Through the websocket, you'll get progress updates and the final masterpiece when it's ready!

Under the Hood 🔧

The Connection Conductor

Our ConnectionManager is like an air traffic controller for websockets - keeping everything flowing smoothly between clients and ComfyUI.

The ComfyUI Wrangler

The ComfyUIManager is the boss of ComfyUI - it starts it up, sends it work, and makes sure it's behaving properly.

The Workflow Detective

Our analysis tools peek into workflows to figure out what makes them tick - inputs, outputs, and how everything connects.

Join the Fun! 🤝

  1. Fork it!
  2. Branch it!
  3. Change it!
  4. Pull request it!

Disclaimer ⚠️

This software is provided "as is", without warranty of any kind, express or implied. The authors or copyright holders shall not be liable for any claim, damages or other liability arising from the use of the software.

Fine Print

MIT License - Go wild, just remember where you got it from!

About

ComfyAPI exposes ComfyUI as a service capable of running in a serverless environment. It consists of a REST API for scheduling jobs and querying status, a Websocket API for real-time updates and image generation results, a lifecycle manager for dynamically managing and monitoring the ComfyUI process, and custom nodes for ComfyUI integration

Topics

comfyuicomfyui-apicomfyui-nodes

Resources

Readme
MIT license
Activity

Stars

4 stars

Watchers

1 watching

Forks

0 forks
Report repository

Releases

Packages

Used by

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { injectUserscript("// Add copy buttons to all 
 blocks\n(function() {\n function addCopyButtons() {\n document.querySelectorAll('pre code').forEach(function(codeBlock) {\n if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;\n codeBlock.parentElement.setAttribute('data-copy-added', 'true');\n \n var btn = document.createElement('button');\n btn.textContent = 'Copy';\n btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';\n btn.onmouseover = function() { this.style.opacity = '1'; };\n btn.onmouseout = function() { this.style.opacity = '0.7'; };\n btn.onclick = function() {\n navigator.clipboard.writeText(codeBlock.textContent).then(function() {\n btn.textContent = 'Copied!';\n setTimeout(function() { btn.textContent = 'Copy'; }, 1500);\n });\n };\n codeBlock.parentElement.style.position = 'relative';\n codeBlock.parentElement.appendChild(btn);\n });\n }\n \n addCopyButtons();\n \n // Re-run on dynamic content\n var observer = new MutationObserver(addCopyButtons);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Add Copy Buttons to Code Blocks");
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
ComfyAPI
A friendly FastAPI-based service that provides REST API and WebSocket interfaces to ComfyUI, making it easy to run AI image generation workflows remotely.
What's This All About?
ComfyAPI sits between your applications and ComfyUI, handling the communication details so you can focus on creating images. It manages process lifecycles and connections behind the scenes.
ComfyUI has powerful capabilities, but its communication protocols can be complex. This project bridges that gap by providing a simple standardize REST interface that applications can use. Whether you're working with web apps, mobile services, or automation scripts, ComfyAPI simplifies the integration.
How It Works
ComfyAPI connects your applications to ComfyUI through several components:
  • API Layer - Offers a structured REST interface for applications
  • Protocol Bridge - Handles conversion between HTTP requests and ComfyUI's WebSocket messages
  • Connection Management - Maintains the websocket connections with proper lifecycle handling
  • Custom Nodes - Extends ComfyUI with specialized input/output nodes for API integration
  • Input Processing - Validates and formats inputs for ComfyUI workflows
  • Output Streaming - Delivers results back through websockets in real-time
Built on FastAPI's asynchronous foundation and equipped with specialized connection managers, the system can handle numerous concurrent requests, making it suitable for multi-user environments or high-volume processing scenarios. This abstraction lets you work with ComfyUI through straightforward API calls without worrying about its internal implementation details.
Features ✨
  • REST API - Structured endpoints for workflow execution
  • WebSocket Interface - Real-time updates during image generation
  • Connection Handling - Automatic management of client-backend connections
  • Workflow Analysis - Automatic extraction of inputs and outputs from workflows
  • API Key Auth - Simple security for your endpoints
  • Auto-Cleanup - Background handling of idle connections
Project Structure 📦
├── src/
│ ├── api/ # API endpoints and routers
│ ├── comfyui/ # ComfyUI integration code
│ ├── data/ # Data models and schemas
│ └── utils/ # Helper utilities
├── workflows/ # Example workflow definitions
├── custom_nodes/ # ComfyUI custom input/output nodes
├── .env # Configuration settings
└── .env.sample # Template configuration file

Requirements 🏊
  • Python 3.9+
  • ComfyUI installed and ready to go
  • Access to wherever ComfyUI lives on your system
Getting Started 🚀
  1. Grab the code:
    git clone https://github.com/piewared/ComfyAPI.git
cd ComfyAPI
  2. Set up your Python virtual environment:
    python -m venv .venv
source .venv/bin/activate # On Windows: .venv\Scripts\activate
  3. Install python dependencies
    pip install -r requirements.txt
  4. Copy the provided .env template:
    cp .env.sample .env
  5. Set the path to your ComfyUI installation and your API key in the .env file:
    COMFYUI_BASE_PATH=/path/to/ComfyUI
APP_API_KEY=your_secure_api_key

    The API key is used to authenticate requests to the API. It should be kept secret and only shared with trusted applications.
Fire It Up! 🔥
uvicorn src.api.app:app --host 127.0.0.1 --port 8000 --reload
How to Use This Thing 🛠️
Creating ComfyAPI Workflows in ComfyUI
  1. Install the ComfyUI custom nodes
    • Copy the custom_nodes/ComfyAPI folder to your ComfyUI installation's custom_nodes directory
  2. Create a workflow in ComfyUI:

    • Add nodes and connections as usual to build your image generation process
    • Use the ComfyAPI input and output nodes to define your workflow's inputs and outputs
Knocking on the Door (Authentication)
Don't forget your unique API key! Add this to your request headers:
X-API-Key: APP_API_KEY

Playing with Workflows
  1. See what workflows are available:
    GET /workflows/

  2. Look under the hood of a workflow to get its requested inputs:
    GET /workflows/{workflow_id}

  3. Get yourself a websocket:
    • Use your favorite websocket client to connect to /ws/register with your API key
    • You'll get a response containing a connection ID to use in the next step:
    {"websocket_cid":"7e51a24f2cbf4873b205a414aab33897"}

  4. Populate the input nodes and make the magic happen:
    POST /workflows/{workflow_id}/queue

    With this in the body:
    {
"websocket_cid": "your_websocket_cid",
"inputs": [
{
"node_id": "node_1",
"value": "https://example.com/image.jpg"
}
]
}
  5. Sit back and enjoy the show:
Through the websocket, you'll get progress updates and the final masterpiece when it's ready!
Under the Hood 🔧
The Connection Conductor
Our ConnectionManager is like an air traffic controller for websockets - keeping everything flowing smoothly between clients and ComfyUI.
The ComfyUI Wrangler
The ComfyUIManager is the boss of ComfyUI - it starts it up, sends it work, and makes sure it's behaving properly.
The Workflow Detective
Our analysis tools peek into workflows to figure out what makes them tick - inputs, outputs, and how everything connects.
Join the Fun! 🤝
  1. Fork it!
  2. Branch it!
  3. Change it!
  4. Pull request it!
Disclaimer ⚠️
This software is provided "as is", without warranty of any kind, express or implied. The authors or copyright holders shall not be liable for any claim, damages or other liability arising from the use of the software.
Fine Print
MIT License - Go wild, just remember where you got it from!
About
ComfyAPI exposes ComfyUI as a service capable of running in a serverless environment. It consists of a REST API for scheduling jobs and querying status, a Websocket API for real-time updates and image generation results, a lifecycle manager for dynamically managing and monitoring the ComfyUI process, and custom nodes for ComfyUI integration
Topics
comfyuicomfyui-apicomfyui-nodes
Resources
Readme
MIT license
Activity
Stars
4 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Force GitHub README to respect dark mode\n(function() {\n var style = document.createElement('style');\n style.textContent = '\n .markdown-body {\n color-scheme: dark light;\n }\n .markdown-body pre { background: #161b22 !important; }\n .markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }\n .markdown-body table th, .markdown-body table td { border-color: #30363d !important; }\n .markdown-body img { background: #0d1117; }\n .markdown-body blockquote { border-left-color: #8b949e; }\n .markdown-body hr { border-color: #30363d; }\n ';\n document.head.appendChild(style);\n})();", "GitHub Dark Mode README Fix");
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
ComfyAPI
A friendly FastAPI-based service that provides REST API and WebSocket interfaces to ComfyUI, making it easy to run AI image generation workflows remotely.
What's This All About?
ComfyAPI sits between your applications and ComfyUI, handling the communication details so you can focus on creating images. It manages process lifecycles and connections behind the scenes.
ComfyUI has powerful capabilities, but its communication protocols can be complex. This project bridges that gap by providing a simple standardize REST interface that applications can use. Whether you're working with web apps, mobile services, or automation scripts, ComfyAPI simplifies the integration.
How It Works
ComfyAPI connects your applications to ComfyUI through several components:
  • API Layer - Offers a structured REST interface for applications
  • Protocol Bridge - Handles conversion between HTTP requests and ComfyUI's WebSocket messages
  • Connection Management - Maintains the websocket connections with proper lifecycle handling
  • Custom Nodes - Extends ComfyUI with specialized input/output nodes for API integration
  • Input Processing - Validates and formats inputs for ComfyUI workflows
  • Output Streaming - Delivers results back through websockets in real-time
Built on FastAPI's asynchronous foundation and equipped with specialized connection managers, the system can handle numerous concurrent requests, making it suitable for multi-user environments or high-volume processing scenarios. This abstraction lets you work with ComfyUI through straightforward API calls without worrying about its internal implementation details.
Features ✨
  • REST API - Structured endpoints for workflow execution
  • WebSocket Interface - Real-time updates during image generation
  • Connection Handling - Automatic management of client-backend connections
  • Workflow Analysis - Automatic extraction of inputs and outputs from workflows
  • API Key Auth - Simple security for your endpoints
  • Auto-Cleanup - Background handling of idle connections
Project Structure 📦
├── src/
│ ├── api/ # API endpoints and routers
│ ├── comfyui/ # ComfyUI integration code
│ ├── data/ # Data models and schemas
│ └── utils/ # Helper utilities
├── workflows/ # Example workflow definitions
├── custom_nodes/ # ComfyUI custom input/output nodes
├── .env # Configuration settings
└── .env.sample # Template configuration file

Requirements 🏊
  • Python 3.9+
  • ComfyUI installed and ready to go
  • Access to wherever ComfyUI lives on your system
Getting Started 🚀
  1. Grab the code:
    git clone https://github.com/piewared/ComfyAPI.git
cd ComfyAPI
  2. Set up your Python virtual environment:
    python -m venv .venv
source .venv/bin/activate # On Windows: .venv\Scripts\activate
  3. Install python dependencies
    pip install -r requirements.txt
  4. Copy the provided .env template:
    cp .env.sample .env
  5. Set the path to your ComfyUI installation and your API key in the .env file:
    COMFYUI_BASE_PATH=/path/to/ComfyUI
APP_API_KEY=your_secure_api_key

    The API key is used to authenticate requests to the API. It should be kept secret and only shared with trusted applications.
Fire It Up! 🔥
uvicorn src.api.app:app --host 127.0.0.1 --port 8000 --reload
How to Use This Thing 🛠️
Creating ComfyAPI Workflows in ComfyUI
  1. Install the ComfyUI custom nodes
    • Copy the custom_nodes/ComfyAPI folder to your ComfyUI installation's custom_nodes directory
  2. Create a workflow in ComfyUI:

    • Add nodes and connections as usual to build your image generation process
    • Use the ComfyAPI input and output nodes to define your workflow's inputs and outputs
Knocking on the Door (Authentication)
Don't forget your unique API key! Add this to your request headers:
X-API-Key: APP_API_KEY

Playing with Workflows
  1. See what workflows are available:
    GET /workflows/

  2. Look under the hood of a workflow to get its requested inputs:
    GET /workflows/{workflow_id}

  3. Get yourself a websocket:
    • Use your favorite websocket client to connect to /ws/register with your API key
    • You'll get a response containing a connection ID to use in the next step:
    {"websocket_cid":"7e51a24f2cbf4873b205a414aab33897"}

  4. Populate the input nodes and make the magic happen:
    POST /workflows/{workflow_id}/queue

    With this in the body:
    {
"websocket_cid": "your_websocket_cid",
"inputs": [
{
"node_id": "node_1",
"value": "https://example.com/image.jpg"
}
]
}
  5. Sit back and enjoy the show:
Through the websocket, you'll get progress updates and the final masterpiece when it's ready!
Under the Hood 🔧
The Connection Conductor
Our ConnectionManager is like an air traffic controller for websockets - keeping everything flowing smoothly between clients and ComfyUI.
The ComfyUI Wrangler
The ComfyUIManager is the boss of ComfyUI - it starts it up, sends it work, and makes sure it's behaving properly.
The Workflow Detective
Our analysis tools peek into workflows to figure out what makes them tick - inputs, outputs, and how everything connects.
Join the Fun! 🤝
  1. Fork it!
  2. Branch it!
  3. Change it!
  4. Pull request it!
Disclaimer ⚠️
This software is provided "as is", without warranty of any kind, express or implied. The authors or copyright holders shall not be liable for any claim, damages or other liability arising from the use of the software.
Fine Print
MIT License - Go wild, just remember where you got it from!
About
ComfyAPI exposes ComfyUI as a service capable of running in a serverless environment. It consists of a REST API for scheduling jobs and querying status, a Websocket API for real-time updates and image generation results, a lifecycle manager for dynamically managing and monitoring the ComfyUI process, and custom nodes for ComfyUI integration
Topics
comfyuicomfyui-apicomfyui-nodes
Resources
Readme
MIT license
Activity
Stars
4 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Highlight search terms from Google/DuckDuckGo/Bing referrer\n(function() {\n var ref = document.referrer;\n var terms = [];\n \n if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {\n var url = new URL(ref);\n var q = url.searchParams.get('q') || url.searchParams.get('p');\n if (q) {\n terms = q.split(/\\s+/).filter(function(t) { return t.length > 2; });\n }\n }\n \n if (terms.length === 0) return;\n \n var style = document.createElement('style');\n style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';\n document.head.appendChild(style);\n \n function highlight(node) {\n if (node.nodeType === 3) { // text node\n var text = node.textContent;\n var found = false;\n terms.forEach(function(term) {\n var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\') + ')', 'gi');\n if (regex.test(text)) {\n found = true;\n var frag = document.createDocumentFragment();\n var parts = text.split(regex);\n parts.forEach(function(part, i) {\n if (i % 2 === 0) {\n frag.appendChild(document.createTextNode(part));\n } else {\n var span = document.createElement('span');\n span.className = 'userscript-highlight';\n span.textContent = part;\n frag.appendChild(span);\n }\n });\n node.parentNode.replaceChild(frag, node);\n }\n });\n } else if (node.nodeType === 1 && node.childNodes) { // element\n var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];\n if (!skipTags.includes(node.tagName)) {\n Array.from(node.childNodes).forEach(highlight);\n }\n }\n }\n \n highlight(document.body);\n \n // Re-highlight on dynamic content\n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1 || node.nodeType === 3) highlight(node);\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Highlight Search Terms");
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
ComfyAPI
A friendly FastAPI-based service that provides REST API and WebSocket interfaces to ComfyUI, making it easy to run AI image generation workflows remotely.
What's This All About?
ComfyAPI sits between your applications and ComfyUI, handling the communication details so you can focus on creating images. It manages process lifecycles and connections behind the scenes.
ComfyUI has powerful capabilities, but its communication protocols can be complex. This project bridges that gap by providing a simple standardize REST interface that applications can use. Whether you're working with web apps, mobile services, or automation scripts, ComfyAPI simplifies the integration.
How It Works
ComfyAPI connects your applications to ComfyUI through several components:
  • API Layer - Offers a structured REST interface for applications
  • Protocol Bridge - Handles conversion between HTTP requests and ComfyUI's WebSocket messages
  • Connection Management - Maintains the websocket connections with proper lifecycle handling
  • Custom Nodes - Extends ComfyUI with specialized input/output nodes for API integration
  • Input Processing - Validates and formats inputs for ComfyUI workflows
  • Output Streaming - Delivers results back through websockets in real-time
Built on FastAPI's asynchronous foundation and equipped with specialized connection managers, the system can handle numerous concurrent requests, making it suitable for multi-user environments or high-volume processing scenarios. This abstraction lets you work with ComfyUI through straightforward API calls without worrying about its internal implementation details.
Features ✨
  • REST API - Structured endpoints for workflow execution
  • WebSocket Interface - Real-time updates during image generation
  • Connection Handling - Automatic management of client-backend connections
  • Workflow Analysis - Automatic extraction of inputs and outputs from workflows
  • API Key Auth - Simple security for your endpoints
  • Auto-Cleanup - Background handling of idle connections
Project Structure 📦
├── src/
│ ├── api/ # API endpoints and routers
│ ├── comfyui/ # ComfyUI integration code
│ ├── data/ # Data models and schemas
│ └── utils/ # Helper utilities
├── workflows/ # Example workflow definitions
├── custom_nodes/ # ComfyUI custom input/output nodes
├── .env # Configuration settings
└── .env.sample # Template configuration file

Requirements 🏊
  • Python 3.9+
  • ComfyUI installed and ready to go
  • Access to wherever ComfyUI lives on your system
Getting Started 🚀
  1. Grab the code:
    git clone https://github.com/piewared/ComfyAPI.git
cd ComfyAPI
  2. Set up your Python virtual environment:
    python -m venv .venv
source .venv/bin/activate # On Windows: .venv\Scripts\activate
  3. Install python dependencies
    pip install -r requirements.txt
  4. Copy the provided .env template:
    cp .env.sample .env
  5. Set the path to your ComfyUI installation and your API key in the .env file:
    COMFYUI_BASE_PATH=/path/to/ComfyUI
APP_API_KEY=your_secure_api_key

    The API key is used to authenticate requests to the API. It should be kept secret and only shared with trusted applications.
Fire It Up! 🔥
uvicorn src.api.app:app --host 127.0.0.1 --port 8000 --reload
How to Use This Thing 🛠️
Creating ComfyAPI Workflows in ComfyUI
  1. Install the ComfyUI custom nodes
    • Copy the custom_nodes/ComfyAPI folder to your ComfyUI installation's custom_nodes directory
  2. Create a workflow in ComfyUI:

    • Add nodes and connections as usual to build your image generation process
    • Use the ComfyAPI input and output nodes to define your workflow's inputs and outputs
Knocking on the Door (Authentication)
Don't forget your unique API key! Add this to your request headers:
X-API-Key: APP_API_KEY

Playing with Workflows
  1. See what workflows are available:
    GET /workflows/

  2. Look under the hood of a workflow to get its requested inputs:
    GET /workflows/{workflow_id}

  3. Get yourself a websocket:
    • Use your favorite websocket client to connect to /ws/register with your API key
    • You'll get a response containing a connection ID to use in the next step:
    {"websocket_cid":"7e51a24f2cbf4873b205a414aab33897"}

  4. Populate the input nodes and make the magic happen:
    POST /workflows/{workflow_id}/queue

    With this in the body:
    {
"websocket_cid": "your_websocket_cid",
"inputs": [
{
"node_id": "node_1",
"value": "https://example.com/image.jpg"
}
]
}
  5. Sit back and enjoy the show:
Through the websocket, you'll get progress updates and the final masterpiece when it's ready!
Under the Hood 🔧
The Connection Conductor
Our ConnectionManager is like an air traffic controller for websockets - keeping everything flowing smoothly between clients and ComfyUI.
The ComfyUI Wrangler
The ComfyUIManager is the boss of ComfyUI - it starts it up, sends it work, and makes sure it's behaving properly.
The Workflow Detective
Our analysis tools peek into workflows to figure out what makes them tick - inputs, outputs, and how everything connects.
Join the Fun! 🤝
  1. Fork it!
  2. Branch it!
  3. Change it!
  4. Pull request it!
Disclaimer ⚠️
This software is provided "as is", without warranty of any kind, express or implied. The authors or copyright holders shall not be liable for any claim, damages or other liability arising from the use of the software.
Fine Print
MIT License - Go wild, just remember where you got it from!
About
ComfyAPI exposes ComfyUI as a service capable of running in a serverless environment. It consists of a REST API for scheduling jobs and querying status, a Websocket API for real-time updates and image generation results, a lifecycle manager for dynamically managing and monitoring the ComfyUI process, and custom nodes for ComfyUI integration
Topics
comfyuicomfyui-apicomfyui-nodes
Resources
Readme
MIT license
Activity
Stars
4 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Strip utm_, fbclid, gclid, etc. from all links on page\n(function() {\n var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',\n 'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',\n 'ref', 'ref_src', 'source', 'medium', 'campaign'];\n \n function cleanUrl(url) {\n try {\n var u = new URL(url, window.location.origin);\n var changed = false;\n trackingParams.forEach(function(p) {\n if (u.searchParams.has(p)) {\n u.searchParams.delete(p);\n changed = true;\n }\n });\n return changed ? u.toString() : url;\n } catch (e) {\n return url;\n }\n }\n \n function cleanLinks() {\n document.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n \n cleanLinks();\n \n var observer = new MutationObserver(function(mutations) {\n mutations.forEach(function(m) {\n m.addedNodes.forEach(function(node) {\n if (node.nodeType === 1) {\n if (node.tagName === 'A') cleanLinks();\n node.querySelectorAll('a[href]').forEach(function(a) {\n var clean = cleanUrl(a.href);\n if (clean !== a.href) a.href = clean;\n });\n }\n });\n });\n });\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "Remove Tracking Parameters from Links");
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
ComfyAPI
A friendly FastAPI-based service that provides REST API and WebSocket interfaces to ComfyUI, making it easy to run AI image generation workflows remotely.
What's This All About?
ComfyAPI sits between your applications and ComfyUI, handling the communication details so you can focus on creating images. It manages process lifecycles and connections behind the scenes.
ComfyUI has powerful capabilities, but its communication protocols can be complex. This project bridges that gap by providing a simple standardize REST interface that applications can use. Whether you're working with web apps, mobile services, or automation scripts, ComfyAPI simplifies the integration.
How It Works
ComfyAPI connects your applications to ComfyUI through several components:
  • API Layer - Offers a structured REST interface for applications
  • Protocol Bridge - Handles conversion between HTTP requests and ComfyUI's WebSocket messages
  • Connection Management - Maintains the websocket connections with proper lifecycle handling
  • Custom Nodes - Extends ComfyUI with specialized input/output nodes for API integration
  • Input Processing - Validates and formats inputs for ComfyUI workflows
  • Output Streaming - Delivers results back through websockets in real-time
Built on FastAPI's asynchronous foundation and equipped with specialized connection managers, the system can handle numerous concurrent requests, making it suitable for multi-user environments or high-volume processing scenarios. This abstraction lets you work with ComfyUI through straightforward API calls without worrying about its internal implementation details.
Features ✨
  • REST API - Structured endpoints for workflow execution
  • WebSocket Interface - Real-time updates during image generation
  • Connection Handling - Automatic management of client-backend connections
  • Workflow Analysis - Automatic extraction of inputs and outputs from workflows
  • API Key Auth - Simple security for your endpoints
  • Auto-Cleanup - Background handling of idle connections
Project Structure 📦
├── src/
│ ├── api/ # API endpoints and routers
│ ├── comfyui/ # ComfyUI integration code
│ ├── data/ # Data models and schemas
│ └── utils/ # Helper utilities
├── workflows/ # Example workflow definitions
├── custom_nodes/ # ComfyUI custom input/output nodes
├── .env # Configuration settings
└── .env.sample # Template configuration file

Requirements 🏊
  • Python 3.9+
  • ComfyUI installed and ready to go
  • Access to wherever ComfyUI lives on your system
Getting Started 🚀
  1. Grab the code:
    git clone https://github.com/piewared/ComfyAPI.git
cd ComfyAPI
  2. Set up your Python virtual environment:
    python -m venv .venv
source .venv/bin/activate # On Windows: .venv\Scripts\activate
  3. Install python dependencies
    pip install -r requirements.txt
  4. Copy the provided .env template:
    cp .env.sample .env
  5. Set the path to your ComfyUI installation and your API key in the .env file:
    COMFYUI_BASE_PATH=/path/to/ComfyUI
APP_API_KEY=your_secure_api_key

    The API key is used to authenticate requests to the API. It should be kept secret and only shared with trusted applications.
Fire It Up! 🔥
uvicorn src.api.app:app --host 127.0.0.1 --port 8000 --reload
How to Use This Thing 🛠️
Creating ComfyAPI Workflows in ComfyUI
  1. Install the ComfyUI custom nodes
    • Copy the custom_nodes/ComfyAPI folder to your ComfyUI installation's custom_nodes directory
  2. Create a workflow in ComfyUI:

    • Add nodes and connections as usual to build your image generation process
    • Use the ComfyAPI input and output nodes to define your workflow's inputs and outputs
Knocking on the Door (Authentication)
Don't forget your unique API key! Add this to your request headers:
X-API-Key: APP_API_KEY

Playing with Workflows
  1. See what workflows are available:
    GET /workflows/

  2. Look under the hood of a workflow to get its requested inputs:
    GET /workflows/{workflow_id}

  3. Get yourself a websocket:
    • Use your favorite websocket client to connect to /ws/register with your API key
    • You'll get a response containing a connection ID to use in the next step:
    {"websocket_cid":"7e51a24f2cbf4873b205a414aab33897"}

  4. Populate the input nodes and make the magic happen:
    POST /workflows/{workflow_id}/queue

    With this in the body:
    {
"websocket_cid": "your_websocket_cid",
"inputs": [
{
"node_id": "node_1",
"value": "https://example.com/image.jpg"
}
]
}
  5. Sit back and enjoy the show:
Through the websocket, you'll get progress updates and the final masterpiece when it's ready!
Under the Hood 🔧
The Connection Conductor
Our ConnectionManager is like an air traffic controller for websockets - keeping everything flowing smoothly between clients and ComfyUI.
The ComfyUI Wrangler
The ComfyUIManager is the boss of ComfyUI - it starts it up, sends it work, and makes sure it's behaving properly.
The Workflow Detective
Our analysis tools peek into workflows to figure out what makes them tick - inputs, outputs, and how everything connects.
Join the Fun! 🤝
  1. Fork it!
  2. Branch it!
  3. Change it!
  4. Pull request it!
Disclaimer ⚠️
This software is provided "as is", without warranty of any kind, express or implied. The authors or copyright holders shall not be liable for any claim, damages or other liability arising from the use of the software.
Fine Print
MIT License - Go wild, just remember where you got it from!
About
ComfyAPI exposes ComfyUI as a service capable of running in a serverless environment. It consists of a REST API for scheduling jobs and querying status, a Websocket API for real-time updates and image generation results, a lifecycle manager for dynamically managing and monitoring the ComfyUI process, and custom nodes for ComfyUI integration
Topics
comfyuicomfyui-apicomfyui-nodes
Resources
Readme
MIT license
Activity
Stars
4 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Auto-enable theater mode on YouTube\n(function() {\n function tryTheater() {\n var btn = document.querySelector('button[aria-label=\"Theater mode\"], ytd-player #player button[title=\"Theater mode\"]');\n if (btn && !btn.classList.contains('activated')) {\n btn.click();\n }\n }\n \n // Try immediately\n tryTheater();\n \n // Try after navigation (SPA)\n var lastUrl = location.href;\n setInterval(function() {\n if (location.href !== lastUrl) {\n lastUrl = location.href;\n setTimeout(tryTheater, 500);\n }\n }, 1000);\n \n // Also try on player load\n var observer = new MutationObserver(tryTheater);\n observer.observe(document.body, { childList: true, subtree: true });\n})();", "YouTube Theater Mode Default");
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
ComfyAPI
A friendly FastAPI-based service that provides REST API and WebSocket interfaces to ComfyUI, making it easy to run AI image generation workflows remotely.
What's This All About?
ComfyAPI sits between your applications and ComfyUI, handling the communication details so you can focus on creating images. It manages process lifecycles and connections behind the scenes.
ComfyUI has powerful capabilities, but its communication protocols can be complex. This project bridges that gap by providing a simple standardize REST interface that applications can use. Whether you're working with web apps, mobile services, or automation scripts, ComfyAPI simplifies the integration.
How It Works
ComfyAPI connects your applications to ComfyUI through several components:
  • API Layer - Offers a structured REST interface for applications
  • Protocol Bridge - Handles conversion between HTTP requests and ComfyUI's WebSocket messages
  • Connection Management - Maintains the websocket connections with proper lifecycle handling
  • Custom Nodes - Extends ComfyUI with specialized input/output nodes for API integration
  • Input Processing - Validates and formats inputs for ComfyUI workflows
  • Output Streaming - Delivers results back through websockets in real-time
Built on FastAPI's asynchronous foundation and equipped with specialized connection managers, the system can handle numerous concurrent requests, making it suitable for multi-user environments or high-volume processing scenarios. This abstraction lets you work with ComfyUI through straightforward API calls without worrying about its internal implementation details.
Features ✨
  • REST API - Structured endpoints for workflow execution
  • WebSocket Interface - Real-time updates during image generation
  • Connection Handling - Automatic management of client-backend connections
  • Workflow Analysis - Automatic extraction of inputs and outputs from workflows
  • API Key Auth - Simple security for your endpoints
  • Auto-Cleanup - Background handling of idle connections
Project Structure 📦
├── src/
│ ├── api/ # API endpoints and routers
│ ├── comfyui/ # ComfyUI integration code
│ ├── data/ # Data models and schemas
│ └── utils/ # Helper utilities
├── workflows/ # Example workflow definitions
├── custom_nodes/ # ComfyUI custom input/output nodes
├── .env # Configuration settings
└── .env.sample # Template configuration file

Requirements 🏊
  • Python 3.9+
  • ComfyUI installed and ready to go
  • Access to wherever ComfyUI lives on your system
Getting Started 🚀
  1. Grab the code:
    git clone https://github.com/piewared/ComfyAPI.git
cd ComfyAPI
  2. Set up your Python virtual environment:
    python -m venv .venv
source .venv/bin/activate # On Windows: .venv\Scripts\activate
  3. Install python dependencies
    pip install -r requirements.txt
  4. Copy the provided .env template:
    cp .env.sample .env
  5. Set the path to your ComfyUI installation and your API key in the .env file:
    COMFYUI_BASE_PATH=/path/to/ComfyUI
APP_API_KEY=your_secure_api_key

    The API key is used to authenticate requests to the API. It should be kept secret and only shared with trusted applications.
Fire It Up! 🔥
uvicorn src.api.app:app --host 127.0.0.1 --port 8000 --reload
How to Use This Thing 🛠️
Creating ComfyAPI Workflows in ComfyUI
  1. Install the ComfyUI custom nodes
    • Copy the custom_nodes/ComfyAPI folder to your ComfyUI installation's custom_nodes directory
  2. Create a workflow in ComfyUI:

    • Add nodes and connections as usual to build your image generation process
    • Use the ComfyAPI input and output nodes to define your workflow's inputs and outputs
Knocking on the Door (Authentication)
Don't forget your unique API key! Add this to your request headers:
X-API-Key: APP_API_KEY

Playing with Workflows
  1. See what workflows are available:
    GET /workflows/

  2. Look under the hood of a workflow to get its requested inputs:
    GET /workflows/{workflow_id}

  3. Get yourself a websocket:
    • Use your favorite websocket client to connect to /ws/register with your API key
    • You'll get a response containing a connection ID to use in the next step:
    {"websocket_cid":"7e51a24f2cbf4873b205a414aab33897"}

  4. Populate the input nodes and make the magic happen:
    POST /workflows/{workflow_id}/queue

    With this in the body:
    {
"websocket_cid": "your_websocket_cid",
"inputs": [
{
"node_id": "node_1",
"value": "https://example.com/image.jpg"
}
]
}
  5. Sit back and enjoy the show:
Through the websocket, you'll get progress updates and the final masterpiece when it's ready!
Under the Hood 🔧
The Connection Conductor
Our ConnectionManager is like an air traffic controller for websockets - keeping everything flowing smoothly between clients and ComfyUI.
The ComfyUI Wrangler
The ComfyUIManager is the boss of ComfyUI - it starts it up, sends it work, and makes sure it's behaving properly.
The Workflow Detective
Our analysis tools peek into workflows to figure out what makes them tick - inputs, outputs, and how everything connects.
Join the Fun! 🤝
  1. Fork it!
  2. Branch it!
  3. Change it!
  4. Pull request it!
Disclaimer ⚠️
This software is provided "as is", without warranty of any kind, express or implied. The authors or copyright holders shall not be liable for any claim, damages or other liability arising from the use of the software.
Fine Print
MIT License - Go wild, just remember where you got it from!
About
ComfyAPI exposes ComfyUI as a service capable of running in a serverless environment. It consists of a REST API for scheduling jobs and querying status, a Websocket API for real-time updates and image generation results, a lifecycle manager for dynamically managing and monitoring the ComfyUI process, and custom nodes for ComfyUI integration
Topics
comfyuicomfyui-apicomfyui-nodes
Resources
Readme
MIT license
Activity
Stars
4 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Remove or un-stick sticky/fixed headers that block content\n(function() {\n function unstick() {\n document.querySelectorAll('header, nav, [role=\"banner\"], .header, .navbar, .sticky, .fixed-top, [style*=\"position: fixed\"], [style*=\"position:sticky\"]').forEach(function(el) {\n if (el.style.position === 'fixed' || el.style.position === 'sticky' || \n getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {\n el.style.position = 'static';\n el.style.top = 'auto';\n el.style.zIndex = 'auto';\n }\n });\n }\n \n unstick();\n \n var observer = new MutationObserver(unstick);\n observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });\n})();", "Kill Sticky Headers");
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
ComfyAPI
A friendly FastAPI-based service that provides REST API and WebSocket interfaces to ComfyUI, making it easy to run AI image generation workflows remotely.
What's This All About?
ComfyAPI sits between your applications and ComfyUI, handling the communication details so you can focus on creating images. It manages process lifecycles and connections behind the scenes.
ComfyUI has powerful capabilities, but its communication protocols can be complex. This project bridges that gap by providing a simple standardize REST interface that applications can use. Whether you're working with web apps, mobile services, or automation scripts, ComfyAPI simplifies the integration.
How It Works
ComfyAPI connects your applications to ComfyUI through several components:
  • API Layer - Offers a structured REST interface for applications
  • Protocol Bridge - Handles conversion between HTTP requests and ComfyUI's WebSocket messages
  • Connection Management - Maintains the websocket connections with proper lifecycle handling
  • Custom Nodes - Extends ComfyUI with specialized input/output nodes for API integration
  • Input Processing - Validates and formats inputs for ComfyUI workflows
  • Output Streaming - Delivers results back through websockets in real-time
Built on FastAPI's asynchronous foundation and equipped with specialized connection managers, the system can handle numerous concurrent requests, making it suitable for multi-user environments or high-volume processing scenarios. This abstraction lets you work with ComfyUI through straightforward API calls without worrying about its internal implementation details.
Features ✨
  • REST API - Structured endpoints for workflow execution
  • WebSocket Interface - Real-time updates during image generation
  • Connection Handling - Automatic management of client-backend connections
  • Workflow Analysis - Automatic extraction of inputs and outputs from workflows
  • API Key Auth - Simple security for your endpoints
  • Auto-Cleanup - Background handling of idle connections
Project Structure 📦
├── src/
│ ├── api/ # API endpoints and routers
│ ├── comfyui/ # ComfyUI integration code
│ ├── data/ # Data models and schemas
│ └── utils/ # Helper utilities
├── workflows/ # Example workflow definitions
├── custom_nodes/ # ComfyUI custom input/output nodes
├── .env # Configuration settings
└── .env.sample # Template configuration file

Requirements 🏊
  • Python 3.9+
  • ComfyUI installed and ready to go
  • Access to wherever ComfyUI lives on your system
Getting Started 🚀
  1. Grab the code:
    git clone https://github.com/piewared/ComfyAPI.git
cd ComfyAPI
  2. Set up your Python virtual environment:
    python -m venv .venv
source .venv/bin/activate # On Windows: .venv\Scripts\activate
  3. Install python dependencies
    pip install -r requirements.txt
  4. Copy the provided .env template:
    cp .env.sample .env
  5. Set the path to your ComfyUI installation and your API key in the .env file:
    COMFYUI_BASE_PATH=/path/to/ComfyUI
APP_API_KEY=your_secure_api_key

    The API key is used to authenticate requests to the API. It should be kept secret and only shared with trusted applications.
Fire It Up! 🔥
uvicorn src.api.app:app --host 127.0.0.1 --port 8000 --reload
How to Use This Thing 🛠️
Creating ComfyAPI Workflows in ComfyUI
  1. Install the ComfyUI custom nodes
    • Copy the custom_nodes/ComfyAPI folder to your ComfyUI installation's custom_nodes directory
  2. Create a workflow in ComfyUI:

    • Add nodes and connections as usual to build your image generation process
    • Use the ComfyAPI input and output nodes to define your workflow's inputs and outputs
Knocking on the Door (Authentication)
Don't forget your unique API key! Add this to your request headers:
X-API-Key: APP_API_KEY

Playing with Workflows
  1. See what workflows are available:
    GET /workflows/

  2. Look under the hood of a workflow to get its requested inputs:
    GET /workflows/{workflow_id}

  3. Get yourself a websocket:
    • Use your favorite websocket client to connect to /ws/register with your API key
    • You'll get a response containing a connection ID to use in the next step:
    {"websocket_cid":"7e51a24f2cbf4873b205a414aab33897"}

  4. Populate the input nodes and make the magic happen:
    POST /workflows/{workflow_id}/queue

    With this in the body:
    {
"websocket_cid": "your_websocket_cid",
"inputs": [
{
"node_id": "node_1",
"value": "https://example.com/image.jpg"
}
]
}
  5. Sit back and enjoy the show:
Through the websocket, you'll get progress updates and the final masterpiece when it's ready!
Under the Hood 🔧
The Connection Conductor
Our ConnectionManager is like an air traffic controller for websockets - keeping everything flowing smoothly between clients and ComfyUI.
The ComfyUI Wrangler
The ComfyUIManager is the boss of ComfyUI - it starts it up, sends it work, and makes sure it's behaving properly.
The Workflow Detective
Our analysis tools peek into workflows to figure out what makes them tick - inputs, outputs, and how everything connects.
Join the Fun! 🤝
  1. Fork it!
  2. Branch it!
  3. Change it!
  4. Pull request it!
Disclaimer ⚠️
This software is provided "as is", without warranty of any kind, express or implied. The authors or copyright holders shall not be liable for any claim, damages or other liability arising from the use of the software.
Fine Print
MIT License - Go wild, just remember where you got it from!
About
ComfyAPI exposes ComfyUI as a service capable of running in a serverless environment. It consists of a REST API for scheduling jobs and querying status, a Websocket API for real-time updates and image generation results, a lifecycle manager for dynamically managing and monitoring the ComfyUI process, and custom nodes for ComfyUI integration
Topics
comfyuicomfyui-apicomfyui-nodes
Resources
Readme
MIT license
Activity
Stars
4 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
injectUserscript("// Universal Dark Mode - works on any site\n(function() {\n var enabled = true;\n \n function applyDarkMode() {\n if (!enabled) return;\n \n // Create style element if it doesn't exist\n var style = document.getElementById('universal-dark-mode-style');\n if (!style) {\n style = document.createElement('style');\n style.id = 'universal-dark-mode-style';\n document.head.appendChild(style);\n }\n \n // Dark mode CSS - inverts colors but preserves images/video\n style.textContent = '\n /* Invert everything except media */\n html {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #1a1a2e !important;\n }\n \n /* Restore images, videos, iframes, canvas */\n img, video, iframe, canvas, svg, picture, [style*=\"background-image\"] {\n filter: invert(1) hue-rotate(180deg) !important;\n }\n \n /* Preserve specific elements that should not be inverted */\n .no-dark-mode, .no-dark-mode *,\n [data-theme=\"light\"], [data-theme=\"light\"],\n .ace_editor, .ace_editor *,\n .CodeMirror, .CodeMirror *,\n .monaco-editor, .monaco-editor *,\n .markdown-body pre, .markdown-body pre *,\n .highlight, .highlight *,\n pre code, pre code * {\n filter: none !important;\n }\n \n /* Fix common UI elements */\n .modal, .popup, .dropdown-menu, .tooltip, .popover {\n filter: invert(1) hue-rotate(180deg) !important;\n background: #2d2d44 !important;\n border-color: #444 !important;\n }\n \n /* Scrollbars */\n ::-webkit-scrollbar { background: #1a1a2e !important; }\n ::-webkit-scrollbar-thumb { background: #444 !important; }\n ::-webkit-scrollbar-thumb:hover { background: #555 !important; }\n \n /* Selection */\n ::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }\n ';\n }\n \n function removeDarkMode() {\n var style = document.getElementById('universal-dark-mode-style');\n if (style) style.remove();\n }\n \n // Toggle with Alt+Shift+D\n document.addEventListener('keydown', function(e) {\n if (e.altKey && e.shiftKey && e.key === 'D') {\n e.preventDefault();\n enabled = !enabled;\n if (enabled) {\n applyDarkMode();\n console.log('[Universal Dark Mode] Enabled');\n } else {\n removeDarkMode();\n console.log('[Universal Dark Mode] Disabled');\n }\n }\n });\n \n // Apply on load\n applyDarkMode();\n \n // Re-apply on dynamic content\n var observer = new MutationObserver(function(mutations) {\n if (enabled && !document.getElementById('universal-dark-mode-style')) {\n applyDarkMode();\n }\n });\n observer.observe(document.head, { childList: true });\n \n console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');\n})();", "Universal Dark Mode");
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
ComfyAPI
A friendly FastAPI-based service that provides REST API and WebSocket interfaces to ComfyUI, making it easy to run AI image generation workflows remotely.
What's This All About?
ComfyAPI sits between your applications and ComfyUI, handling the communication details so you can focus on creating images. It manages process lifecycles and connections behind the scenes.
ComfyUI has powerful capabilities, but its communication protocols can be complex. This project bridges that gap by providing a simple standardize REST interface that applications can use. Whether you're working with web apps, mobile services, or automation scripts, ComfyAPI simplifies the integration.
How It Works
ComfyAPI connects your applications to ComfyUI through several components:
  • API Layer - Offers a structured REST interface for applications
  • Protocol Bridge - Handles conversion between HTTP requests and ComfyUI's WebSocket messages
  • Connection Management - Maintains the websocket connections with proper lifecycle handling
  • Custom Nodes - Extends ComfyUI with specialized input/output nodes for API integration
  • Input Processing - Validates and formats inputs for ComfyUI workflows
  • Output Streaming - Delivers results back through websockets in real-time
Built on FastAPI's asynchronous foundation and equipped with specialized connection managers, the system can handle numerous concurrent requests, making it suitable for multi-user environments or high-volume processing scenarios. This abstraction lets you work with ComfyUI through straightforward API calls without worrying about its internal implementation details.
Features ✨
  • REST API - Structured endpoints for workflow execution
  • WebSocket Interface - Real-time updates during image generation
  • Connection Handling - Automatic management of client-backend connections
  • Workflow Analysis - Automatic extraction of inputs and outputs from workflows
  • API Key Auth - Simple security for your endpoints
  • Auto-Cleanup - Background handling of idle connections
Project Structure 📦
├── src/
│ ├── api/ # API endpoints and routers
│ ├── comfyui/ # ComfyUI integration code
│ ├── data/ # Data models and schemas
│ └── utils/ # Helper utilities
├── workflows/ # Example workflow definitions
├── custom_nodes/ # ComfyUI custom input/output nodes
├── .env # Configuration settings
└── .env.sample # Template configuration file

Requirements 🏊
  • Python 3.9+
  • ComfyUI installed and ready to go
  • Access to wherever ComfyUI lives on your system
Getting Started 🚀
  1. Grab the code:
    git clone https://github.com/piewared/ComfyAPI.git
cd ComfyAPI
  2. Set up your Python virtual environment:
    python -m venv .venv
source .venv/bin/activate # On Windows: .venv\Scripts\activate
  3. Install python dependencies
    pip install -r requirements.txt
  4. Copy the provided .env template:
    cp .env.sample .env
  5. Set the path to your ComfyUI installation and your API key in the .env file:
    COMFYUI_BASE_PATH=/path/to/ComfyUI
APP_API_KEY=your_secure_api_key

    The API key is used to authenticate requests to the API. It should be kept secret and only shared with trusted applications.
Fire It Up! 🔥
uvicorn src.api.app:app --host 127.0.0.1 --port 8000 --reload
How to Use This Thing 🛠️
Creating ComfyAPI Workflows in ComfyUI
  1. Install the ComfyUI custom nodes
    • Copy the custom_nodes/ComfyAPI folder to your ComfyUI installation's custom_nodes directory
  2. Create a workflow in ComfyUI:

    • Add nodes and connections as usual to build your image generation process
    • Use the ComfyAPI input and output nodes to define your workflow's inputs and outputs
Knocking on the Door (Authentication)
Don't forget your unique API key! Add this to your request headers:
X-API-Key: APP_API_KEY

Playing with Workflows
  1. See what workflows are available:
    GET /workflows/

  2. Look under the hood of a workflow to get its requested inputs:
    GET /workflows/{workflow_id}

  3. Get yourself a websocket:
    • Use your favorite websocket client to connect to /ws/register with your API key
    • You'll get a response containing a connection ID to use in the next step:
    {"websocket_cid":"7e51a24f2cbf4873b205a414aab33897"}

  4. Populate the input nodes and make the magic happen:
    POST /workflows/{workflow_id}/queue

    With this in the body:
    {
"websocket_cid": "your_websocket_cid",
"inputs": [
{
"node_id": "node_1",
"value": "https://example.com/image.jpg"
}
]
}
  5. Sit back and enjoy the show:
Through the websocket, you'll get progress updates and the final masterpiece when it's ready!
Under the Hood 🔧
The Connection Conductor
Our ConnectionManager is like an air traffic controller for websockets - keeping everything flowing smoothly between clients and ComfyUI.
The ComfyUI Wrangler
The ComfyUIManager is the boss of ComfyUI - it starts it up, sends it work, and makes sure it's behaving properly.
The Workflow Detective
Our analysis tools peek into workflows to figure out what makes them tick - inputs, outputs, and how everything connects.
Join the Fun! 🤝
  1. Fork it!
  2. Branch it!
  3. Change it!
  4. Pull request it!
Disclaimer ⚠️
This software is provided "as is", without warranty of any kind, express or implied. The authors or copyright holders shall not be liable for any claim, damages or other liability arising from the use of the software.
Fine Print
MIT License - Go wild, just remember where you got it from!
About
ComfyAPI exposes ComfyUI as a service capable of running in a serverless environment. It consists of a REST API for scheduling jobs and querying status, a Websocket API for real-time updates and image generation results, a lifecycle manager for dynamically managing and monitoring the ComfyUI process, and custom nodes for ComfyUI integration
Topics
comfyuicomfyui-apicomfyui-nodes
Resources
Readme
MIT license
Activity
Stars
4 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Used by
Contributors
Languages