Why this matters (short)

RunningHub provides a cloud and local execution surface for model workflows; ComfyUI is the visual workflow engine many use to build image and AI pipelines. Properly configuring your RunningHub API key and environment variables avoids authentication failures, runtime errors, and unexpected billing. Integrating Pixelle‑MCP or other MCP connectors requires consistent tokens, endpoints, and a stable local workflow execution pattern.

Read this guide to get a reproducible setup: key creation, environment variables, ComfyUI node configuration, trouble‑shooting common “adding error” messages, and tips for cloud execution. I’ll include exact environment variable names, typical commands, and a short FAQ for voice-search‑friendly answers.

This article links to a reference build for Pixelle‑MCP and RunningHub integration for step validation: Pixelle‑MCP RunningHub integration.

Configuring RunningHub API keys and environment variables

Start by creating or retrieving your RunningHub API key (sometimes called API token or membership key) from your RunningHub account dashboard. Treat it like a password: do not paste it into chats, public repos, or log files. RunningHub authentication typically requires two pieces: an API key and a configured endpoint (e.g., https://api.runninghub.example or a region-specific URL).

Set environment variables on your machine or server so tools like ComfyUI, Pixelle‑MCP, or CI bots pick up the credentials automatically. Use descriptive names to avoid collisions:

export RUNNINGHUB_API_KEY="rk_live_xxx"
export RUNNINGHUB_ENDPOINT="https://api.runninghub.example"
export PIXELLE_MCP_TOKEN="pm_mcp_xxx"  # if needed

On Windows PowerShell:

$env:RUNNINGHUB_API_KEY="rk_live_xxx"
$env:RUNNINGHUB_ENDPOINT="https://api.runninghub.example"

Common pitfalls: forgetting to export variables in the same shell that launches ComfyUI, using the wrong token (membership vs. service token), or placing the key in the wrong config file. If a tool expects a config file (like ~/.runninghub/config.json), create it with strict permissions and the correct JSON structure:

{
  "api_key": "rk_live_xxx",
  "endpoint": "https://api.runninghub.example"
}

Configuring ComfyUI with RunningHub and PIXELLE‑MCP integration

ComfyUI integrates with remote runners via nodes that call external APIs. When you configure the RunningHub node, double‑check: the node endpoint matches your RUNNINGHUB_ENDPOINT, the node’s auth header uses Bearer your_api_key, and the node timeout matches expected job durations.

If you’re using Pixelle‑MCP as a plugin or bridge, ensure the MCP connector has the RunningHub API key and the correct job‑submission schema. Many Pixelle‑MCP connectors accept environment variables or a connector YAML. For example:

pixelle:
  runner: runninghub
  runninghub:
    endpoint: ${RUNNINGHUB_ENDPOINT}
    api_key: ${RUNNINGHUB_API_KEY}

Use this link for the canonical Pixelle‑MCP guide and example connector: Pixelle‑MCP RunningHub integration. It contains sample YAML and node snippets you can drop into a ComfyUI workflow.

Troubleshooting the “ComfyUI tool adding error”: the message appears when ComfyUI fails to register a node or complete a node action. Typical causes include mismatched schema, missing Python dependencies, or network/auth failures. Check ComfyUI logs (console output or comfyui.log) for the node trace and HTTP status codes from RunningHub (401 for auth, 403 for permissions, 4xx/5xx for payload/server issues).

• Verify node schema vs. API schema.
• Confirm API key scope (membership vs. service) and expiry.
• Confirm Python package requirements: some connectors need specific versions of requests or httpx.

Local ComfyUI workflow execution vs. RunningHub cloud execution

Local execution is ideal for debugging, low-latency interactive work, and when GPUs are attached to your workstation. ComfyUI runs nodes locally and can call local models or local inference endpoints. When you push to RunningHub cloud execution, jobs run remotely—this requires packaging or serializing the model inputs, ensuring compatibility, and handling asynchronous job states.

Design your workflow with portability in mind: avoid referencing absolute file paths, use artifact storage (S3-compatible buckets) for large files, and prefer JSON or compressed protobuf payloads for model inputs. For example, instead of /home/user/models/my.pt, upload the model to your private artifact store and reference s3://internal/models/my.pt or a RunningHub asset handle.

Cloud execution tips:

• Set sensible job timeouts and retries in your RunningHub submission payload.
• Stream logs back to the local ComfyUI console or to a centralized log viewer so you can correlate problems.

When testing cloud jobs, use a small payload and a short runtime to validate the end-to-end flow before sending full-size jobs. Implement idempotency keys if the Runner might re-run a job on transient failures.

Debugging common errors and practical fixes

Error: “ComfyUI tool adding error” — common first steps: restart ComfyUI after ensuring environment variables are set in the same shell, verify the node plugin is in the correct plugin folder and up to date, and check that any additional Python packages were installed into ComfyUI’s environment. Reinstall the plugin with the exact version that matches your ComfyUI release if necessary.

Error: 401/403 when submitting to RunningHub — confirm the API key value and type. If you have multiple keys (membership, project, service), try the service token for programmatic access. Rotate keys if you suspect token leakage and update environment variables and connector configs accordingly.

Error: Job created but fails with model load errors — ensure the runner has access to the model artifact and that the model format is supported (e.g., TorchScript vs. PyTorch checkpoint vs. ONNX). For plugin-driven model conversions, add an initial validation node that quickly checks model load on the target runtime.

Best practices and checklist

Before you run production jobs, follow this checklist to reduce friction:

• Verify environment variables (token + endpoint) are exported and available to the process launching ComfyUI.
• Confirm node schemas and connector versions match the RunningHub API.
• Use small test payloads, check logs, then scale up.

Also consider role-based access control on RunningHub: create scoped API keys for CI/CD vs. interactive users, and log token usage so you can trace who submitted which jobs. Enable quotas or cost controls if RunningHub supports them, especially for GPU-heavy workloads.

Finally, keep a short README inside your ComfyUI project documenting environment variable names, expected endpoints, and the link to the Pixelle‑MCP connector so teammates have a reproducible setup.

Suggested micro-markup (FAQ & Article schema)

To increase the chance of appearing in featured snippets and voice search results, add JSON-LD FAQ markup for the three FAQ entries below. Example FAQ JSON-LD (to be inserted into the page head):

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "How do I configure a RunningHub API key for ComfyUI?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Create a RunningHub API key from your dashboard, set RUNNINGHUB_API_KEY and RUNNINGHUB_ENDPOINT as environment variables, and confirm ComfyUI nodes use a Bearer header with that key."
      }
    },
    {
      "@type": "Question",
      "name": "How do I fix the ComfyUI 'adding error' when adding a RunningHub node?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Check node plugin compatibility, verify dependencies, ensure environment variables are exported to the running shell, and inspect ComfyUI logs for HTTP status codes from RunningHub."
      }
    },
    {
      "@type": "Question",
      "name": "How can I run ComfyUI workflows on RunningHub cloud?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Package inputs as portable artifacts, reference remote model locations, submit small test jobs first, and stream logs back to confirm behavior before scaling."
      }
    }
  ]
}

Tip: keep each FAQ answer under 50–60 words to target voice search concise responses and featured snippet formatting.

FAQ (short, voice‑search friendly)

1. How do I configure a RunningHub API key for ComfyUI?

Get an API key from RunningHub, set RUNNINGHUB_API_KEY and RUNNINGHUB_ENDPOINT as environment variables in the same shell you launch ComfyUI, and ensure the ComfyUI RunningHub node uses the key in the Authorization Bearer header.

2. Why does ComfyUI show a “tool adding error” when adding a node?

Usually a mismatched node schema, missing Python deps, or auth failure. Check ComfyUI logs, verify plugin installation and versions, and confirm environment variables and API keys are correct.

3. How do I run a local ComfyUI workflow in the cloud via RunningHub?

Upload artifacts to a remote store or reference a RunningHub asset, adapt your workflow to avoid local absolute paths, submit a small test job, and stream logs back to debug before scaling.

Semantic core (keyword clusters)

Primary keywords (high intent, transactional/technical):

• RunningHub API key configuration
• configuring ComfyUI with RunningHub
• Pixelle‑MCP RunningHub integration

Secondary keywords (informational, medium frequency):

• RunningHub membership API key
• setting environment variables RunningHub API
• local ComfyUI workflow execution
• RunningHub cloud execution
• ComfyUI tool adding error

Clarifying / LSI phrases & synonyms (supporting):

• API token, API secret, bearer token
• environment variables export, dotenv, config.json
• node schema, connector, plugin, dependency
• job submission, artifact storage, S3, endpoint
• error logs, HTTP 401, 403, timeout, retries

Use these phrases naturally in text: “API token”, “endpoint”, “artifact store”, “job timeout”, “node schema mismatch”, “service token”, “role-based access”.

Backlinks and references

Reference guide and connector examples: Pixelle‑MCP RunningHub integration (includes YAML samples and node snippets).

Additional reading: keep your ComfyUI plugin README next to your workflow and include a short script that sets environment variables before launching ComfyUI to avoid shell scoping issues.