comfy.org

The ComfyUI web app is the browser-based version of Comfy, a node-based visual AI creation engine. You use it to build and run generative AI workflows — connecting models, processing steps, and outputs on a canvas where every decision is visible and adjustable. It's aimed at visual professionals who want control over every model, parameter, and output, but it also offers a simplified App Mode for people who are new to node graphs. You can get started for free, and you can flip between the simplified view and the full node graph at any time.

What the ComfyUI Web App Actually Is

ComfyUI is a node-based AI application. Instead of typing a prompt into a single box and hoping for the best, you assemble a pipeline: each node represents a model, a parameter, or a processing step, and you connect them on an infinite canvas. The web app runs this experience in your browser rather than as a separate local install.

The core idea, in the site's own framing, is that "every model, parameter, and processing step is visible and adjustable." That's the main difference from a one-click generator — you can inspect and change what happens at each stage.

The platform also advertises a Developer Platform (Beta) for deploying a ComfyUI workflow as a production API, and it positions itself as the only official reseller of MiniMax commercial-use licenses for running MiniMax models locally on your own hardware. Those are separate offerings from simply using the web app to run workflows.

App Mode vs. the Node Graph

This is the distinction that matters most when you're deciding how to start.

If you're new to ComfyUI, the site explicitly recommends starting with App Mode. The important part is that it isn't a dead end: you can flip back to the node graph view whenever you want to go deeper. So you can start simple and grow into the full editor without changing tools.

How to Get Started in the Browser

1. Open the web app and start for free. The site offers a "Get started for free" entry point, so you can begin without setting up a local environment first.
2. Start in App Mode if you're new. This gives you a simplified view of a workflow rather than an empty canvas full of nodes.
3. Load a community workflow template. Comfy hosts thousands of community-shared workflows. Starting from a proven template and customizing it is faster than building from scratch.
4. Run an image or video workflow. Featured examples on the site include text-to-video, image-to-video, reference-to-video, and image upscaling — so the web app covers both image and video generation pipelines, not just stills.
5. Adjust models and parameters. Because every step is a visible node, you can change the model, tweak parameters, and see exactly where in the pipeline your change takes effect.
6. Flip to the node graph when you need more control. Once you understand the flow, switch views to inspect and modify individual nodes.

Expected result: you end up with a working pipeline you can run repeatedly, and — because the graph is visible — you can explain and modify why it produces what it produces.

What You Can Do in the Web App

• Build AI pipelines by connecting nodes on an infinite canvas.
• Run image workflows, such as image upscaling (the site features a Topaz image-enhance example).
• Run video workflows, including text-to-video, image-to-video, and reference-to-video (featured MiniMax H3 and FLUX 3 Video examples).
• Browse and remix community workflows — start from a template and customize it.
• Deploy a workflow as a production API through the Developer Platform (Beta), if you need to move from experimentation to serving.

Common Points to Watch

• App Mode is a view, not a separate app. If a control you need isn't exposed, switch to the node graph rather than assuming the feature is missing.
• "Free to get started" is not the same as "everything is free." The site has a Pricing page, and commercial licensing (for example, MiniMax commercial-use licenses) is a distinct, request-based offering. Check the pricing page for current terms rather than assuming all usage is free.
• The Developer Platform is in Beta. If you're planning to deploy workflows as a production API, treat it as a beta offering and read the docs before depending on it.
• Templates are a starting point, not a guarantee. A community workflow that works for someone else's model setup may need parameter or model adjustments for yours — that's exactly what the node graph is for.

The short version: the ComfyUI web app lets you run node-based visual AI workflows in the browser, start simple in App Mode, and drop into the full node graph whenever you need real control.

A free hosted REST API like ReqRes gives you a real HTTP endpoint you can call immediately—no signup, no local server, no database setup. You get predictable JSON responses for users, resources, login, and registration, which makes it useful for front-end demos, integration tests, learning HTTP clients, and prototyping. What it is not is a production backend for your app: the data is shared, resets periodically, and you don't control the schema. If you need persistent, private data with auth and logs, that's where an account-based backend or a commercial licence comes in.

What "free REST API for testing and prototyping" actually means

The phrase sounds vague, so it helps to separate two things people often conflate:

• A mock/sample API — a public, hosted service with fixed or semi-fixed endpoints that return realistic-looking JSON. You don't own the data. It exists so you can point code at a URL and get a response.
• A real backend you configure — a service where you define collections, schemas, authentication, and logging, and where your data persists and belongs to you.

ReqRes's landing page describes both: a free REST API for testing and prototyping with real responses and no signup, plus an option to build your own backend with collections, auth, and logs at app.reqres.in. Those are different products with different trade-offs. The free public endpoints are the "point and go" part; the account-based backend is the "own your data" part.

What you can do with the no-signup public endpoints

1. Front-end demos without a backend

If you're building a UI and need data to render, you can fetch from a public endpoint instead of hardcoding arrays. This keeps your demo code closer to real fetch logic:

async function loadUsers(page = 1) {
  const res = await fetch(`https://reqres.in/api/users?page=${page}`);
  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  const { data, total, page: current } = await res.json();
  return { users: data, total, page: current };
}

You get pagination fields, a data array, and support metadata—enough to build list views, loading states, and empty states.

2. Integration and contract tests

You can assert that your HTTP layer handles status codes, headers, and JSON shapes correctly. Typical checks:

• GET /api/users/2 returns 200 with a data object.
• GET /api/users/23 returns 404 (a non-existent user).
• POST /api/login with valid credentials returns a token; with missing fields returns 400.

This is useful for testing your client wrapper, retry logic, error handling, and serialization—without spinning up your own server.

3. Learning HTTP clients and tooling

If you're new to fetch, Axios, curl, Postman, or HTTPie, a hosted API is a low-friction target. You can practice:

• Sending query parameters (?page=2, ?delay=3).
• Setting headers and reading response headers.
• Handling POST, PUT, PATCH, DELETE.
• Observing status codes for success and failure.

4. Deliberate failure and latency testing

Endpoints that return 404 on purpose, or that accept a delay parameter, let you test how your app behaves when things go wrong or slow down. That's hard to do reliably against a happy-path local mock.

What the public endpoints are not good for

The key limitation: you don't own the data, and other people are hitting the same endpoints. Treat responses as illustrative, not authoritative.

When you'd move to an account-based backend

Consider app.reqres.in (collections, auth, logs) when any of these are true:

• You need your own collections and fields, not the fixed demo schema.
• You need data to persist between sessions and belong only to you.
• You need real authentication flows you can rely on in a demo or internal tool.
• You need request logs to debug what your client actually sent.
• You're working with a team and need shared, stable endpoints.

The trade-off is setup and, eventually, cost. The public endpoints require none; the backend requires an account and configuration.

Where pricing and licensing become relevant

The site signals a commercial licence and an upgrade path (with Stripe as the payment platform), but specific prices, plan tiers, and limits aren't stated here—so don't assume numbers. What you can reason about:

• Prototyping and learning → free public endpoints are usually enough.
• Internal tools, demos for clients, or anything you don't want reset → an account-based backend is the natural next step.
• Production or commercial use → check the licence terms and any paid plan, because "free for testing" and "free for commercial production" are not the same thing.

Before committing, read the current terms on the site rather than relying on secondhand summaries, since pricing and licence scope change.

A quick decision checklist

1. Do you need data that persists and is private? If yes → account-based backend.
2. Do you need a custom schema? If yes → account-based backend.
3. Are you only testing HTTP behavior, UI rendering, or learning a client? If yes → free public endpoints.
4. Will this touch real users or revenue? If yes → review the licence and any paid plan first.
5. Do you need logs and team access? If yes → account-based backend.

If you answer "no" to 1, 2, 4, and 5, the free hosted API is likely all you need. If you answer "yes" to any of them, plan for the account-based path.

The Comfy app is a node-based visual AI creation engine for building generative workflows. You connect models, processing steps, and outputs on an infinite canvas where every decision is visible and every step is inspectable. If you're new, start in App Mode — a simplified view of your workflows — and flip back to the node graph view anytime to go deeper. You can begin from a community template or build from scratch.

What the Comfy app actually is

Comfy is positioned as "the AI creation engine for visual professionals who demand control over every model, every parameter, and every output." In practice, that means:

• A node canvas. Models, parameters, and processing steps are connected as nodes on an infinite canvas. Nothing is hidden behind a single prompt box — you can see and adjust each stage.
• A workflow system. A workflow is the chain of nodes you build. It's reusable, shareable, and remixable.
• A model hub. Thousands of models live on one platform, so you're not juggling separate tools per model.

This is the core difference from a typical one-click image generator: control is the point, and the node graph is how that control is expressed.

App Mode vs. the node graph

The two views serve different levels of experience, and you can switch between them freely.

The practical takeaway: you don't have to learn the node graph before you can produce anything. Start in App Mode, then open the graph when you want to understand or change what's happening.

How to get started

1. Get started for free. The site's primary call to action is "Get started for free," which is the entry point for new users.
2. Start from a community template. Browse and remix thousands of community-shared workflows. Beginning from a proven template and customizing it is the recommended path rather than building from zero.
3. Run it in App Mode. If you're new to ComfyUI, App Mode gives you a simplified view so you can run the workflow without parsing the graph first.
4. Flip to the node graph. When you want to go deeper, switch to the graph view to see and adjust every model, parameter, and processing step.
5. Build from scratch (optional). Once the node model makes sense, you can construct pipelines yourself on the infinite canvas.

Expected result: you end up with a working visual AI pipeline you can run, inspect, and modify — not a black box.

What you can do once you're running

The featured workflows on the site show the range of tasks the app covers:

• Video generation — text to video, image to video, and reference to video (including MiniMax H3 workflows).
• Image work — image upscaling and enhancement (for example, Topaz: Image Enhance).
• Product and commercial output — a product advertisement video workflow is featured as a staff pick.

These are examples of what a workflow can produce, not a fixed menu — the node canvas is what lets you assemble steps like these yourself.

Where to go next

Two directions, depending on whether you're creating or shipping:

• Remix and learn. Browse community workflows, start from a template, and customize. This is the fastest way to build intuition for how nodes connect.
• Deploy as a production API. The Developer Platform (currently in beta) lets you deploy your ComfyUI workflow as a production API — useful when a workflow you've built needs to run as part of a larger system rather than by hand.

A note on commercial use

Comfy states it is the only official reseller of MiniMax commercial-use licenses, for running MiniMax models locally on your own hardware. According to the site, that includes full commercial rights to your outputs, fine-tuning and LoRA training, and client and downstream work. If your work needs commercial rights, that's a specific path to look into rather than an assumption that applies to every model or workflow.

The ComfyUI app is a node-based visual AI creation tool: you build generative workflows by connecting models, processing steps, and outputs on a canvas where every decision is visible and adjustable. It suits people who want control over each parameter rather than a single prompt box — and if you're new, you can start in App Mode, a simplified view, then flip back to the node graph whenever you want to go deeper. You can begin from a community template or build from scratch.

The core model: nodes on a canvas

Instead of hiding the pipeline behind one text field, ComfyUI exposes it as a graph. Each node represents something concrete — a model, a parameter, a processing step, an output — and you wire them together.

What that gives you:

• Inspectability. Every step is visible, so you can see exactly where an image or video came from and change one piece without rebuilding everything.
• Adjustability. Models and parameters are individual, editable elements rather than fixed settings.
• Reuse. A working graph becomes a template you can rerun, remix, or adapt.

The canvas is described as infinite, so complex pipelines don't run out of room.

App Mode vs. the node graph

App Mode is a simplified view of your workflows, aimed at people who are new to ComfyUI. It presents the workflow without requiring you to read the full graph.

The important part is that it isn't a separate, locked-down product: you can flip back to the node graph view at any time. A practical way to work is to start in App Mode to get a result, then switch to the graph to see how that result was produced and start changing it.

Starting a workflow

There are two entry points, and they serve different goals.

Comfy's site points to thousands of community-shared workflows you can browse and remix. Starting from one of these is the faster path to a working result; building from scratch is the path to a pipeline that matches your exact process.

Local vs. hosted

The site distinguishes between running things yourself and using hosted options:

• Local / your own hardware. Comfy states it is the only official reseller of MiniMax commercial-use licenses, for running MiniMax models locally on your own hardware. That license is described as including full commercial rights to your outputs, fine-tuning and LoRA training, and client and downstream work.
• Comfy Cloud. The site offers trying MiniMax H3 on Comfy Cloud, noting audio and music are included and it's available globally.
• Production API. A "Developer Platform Beta" lets you deploy your ComfyUI workflow as a production API.

If your concern is commercial rights over what you generate, the local-license route is the one the site spells out; if your concern is not managing hardware, the cloud route is the alternative it names.

What you can build

The featured examples on the site give a sense of the range: product advertisement video, image-to-video, reference-to-video, text-to-video, image upscaling, and image enhancement. These are all built on the same node canvas — the difference is which models and steps you connect.

Getting started

The site's own entry point is a free start ("Get started for free"). From there, the sequence that matches how the product is described is: open App Mode to run something, then switch to the node graph to understand and modify it, and pull in a community workflow when you'd rather adapt than assemble.

The ComfyUI application is a node-based visual AI creation engine: you build generative workflows by connecting models, processing steps, and outputs on an infinite canvas, where every parameter stays visible and adjustable. It suits two kinds of users — beginners who want a simplified view of a working pipeline, and professionals who need to inspect and control each step. You can start for free, and if you later need to run a workflow as a service, Comfy offers a developer platform (currently in beta) for deploying workflows as a production API.

What the ComfyUI application actually is

Comfy describes itself as "the AI creation engine for visual professionals who demand control over every model, every parameter, and every output." In practice that means:

• Node-based pipelines. Instead of a single prompt box, you assemble a graph. Each node represents a model, a processing step, or an output.
• Inspectable decisions. Every step is visible on the canvas, so you can trace why an output looks the way it does and change one piece without rebuilding everything.
• One platform, many models. The site states thousands of models are available on one platform, spanning image, video, audio, and music workflows (for example, featured workflows include text-to-video, image-to-video, reference-to-video, and image upscaling).

If you have used a node editor before, the mental model will be familiar. If not, the important thing is that the graph is not hidden from you — it is the interface.

Two ways to work: App Mode and the node graph

The application gives you two views of the same workflow, and you can move between them.

App Mode (the beginner entry point)

Comfy's own guidance for newcomers is to start with App Mode, described as "a simplified view of your workflows." You interact with the workflow through a reduced set of controls rather than the full graph.

• Use it when you just want to run a workflow and adjust a few visible settings.
• You can flip back to the node graph view at any time to go deeper — App Mode is a layer on top of the graph, not a separate tool.

Node graph view (the control layer)

This is where you connect nodes on the infinite canvas. Use it when you need to change models, reorder processing steps, or debug an output that isn't behaving.

A practical pattern: open a template in App Mode, run it once to see the result, then switch to the graph to understand which node produced what.

Getting started: from template to your own workflow

1. Start for free. The site's primary call to action is "Get started for free," which is the entry point for the hosted experience.
2. Pick a starting point. You can begin from a community template or build from scratch. Comfy points to thousands of community-shared workflows that you can browse and remix — starting from a proven template and customizing it is the lower-risk path.
3. Run it and observe. Execute the workflow and look at the output. In App Mode you'll see the simplified controls; in the graph you'll see each step.
4. Adjust one thing at a time. Change a model, a parameter, or a processing step, then re-run. Because each step is visible, you can attribute changes in output to specific edits.
5. Switch views as needed. Flip between App Mode and the node graph depending on whether you're running or rebuilding.

The featured workflows on the site — such as text-to-video, image-to-video, reference-to-video, image upscaling, and product advertisement video — are useful reference points for what a finished graph looks like in different domains.

Hosted use vs. deploying a workflow as an API

These are different stages of the same workflow, not competing products.

If your goal is to make images or video yourself, stay in the hosted experience. If your goal is to have software call your workflow, the beta developer platform is the relevant path — and because it's beta, expect the interface and docs to evolve.

One more thing worth knowing: commercial licensing

Comfy states it is "the only official reseller of MiniMax commercial-use licenses, for running MiniMax models locally on your own hardware." According to the site, that license includes full commercial rights to your outputs, fine-tuning and LoRA training, and client and downstream work. If your use case requires commercial rights to outputs, this is a specific condition to check before assuming a general license covers you — the site provides a "Request License" path and notes MiniMax H3 is available on Comfy Cloud.

Common sticking points

• Treating App Mode as a separate app. It isn't — it's a simplified view of the same workflow, and you can return to the graph whenever you want.
• Building from scratch on day one. Starting from a community template and remixing it is the documented lower-friction route.
• Assuming the hosted experience and the API are interchangeable. They serve different jobs; the API path is explicitly in beta.
• Assuming pricing or login terms. The site links to a pricing page but the provided material doesn't state plan details, so check that page directly rather than inferring what "free" covers.