Drag-and-drop identity authentication for Flowise workflows

API Key Sprawl Across Visual Workflows

integrate into your applications with this package. Easy to add to any existing project.

Traditional workflow builders require storing API keys for every service integration. Keys get shared across teams, embedded in workflow templates, and become a security nightmare when team members leave.

Store API keys → Share across team → Rotate keys → Update everywhere
  ↓
Developer leaves company → Rotate all their keys → Every workflow breaks

Flowise eliminates API keys entirely. Every workflow gets cryptographic identity instead of shared credentials.

Generate identity once → Share DID → No key rotation needed
  ↓
Developer leaves company → Their workflows keep running → Zero downtime

Install and Build Workflow in 60 Seconds

Installation

JavaScript/TypeScript:

npm install @private.me/flowise flowise

Python:

pip install private-me-flowise

Visual Workflow Builder

In Flowise canvas:

1. Drag xBindIdentityNode onto canvas (generates agent identity)
2. Drag xBindCallNode onto canvas (call services with identity)
3. Connect identity output to call node
4. Run workflow - no API keys needed!

[xBindIdentityNode]
        ↓
[xBindCallNode (serviceName: "payments")]
        ↓
Display result

Python Quick Start

from private_me import flowise

# Connect to low-code workflow
connection = await flowise.connect('my-workflow')

# Execute workflow step with identity auth
result = await connection.send(
    to='workflow-step-123',
    payload={'action': 'transform', 'data': [1, 2, 3]}
)

Result: Agent authenticates to payment service using cryptographic identity. No API keys, no OAuth, no credentials stored anywhere.

Why AI Agents Choose xBind

xBind reduces cognitive load for AI agents by consolidating authentication into a single package. Instead of navigating 36 error surfaces across 5-10 fragmented packages, agents work with one unified interface.

Integration Complexity Comparison

Purchase & Subscription

3-month trial — No credit card required. Start building identity-based workflows immediately.

Tiers

Standard pricing: $5/month Basic • $10/month Pro • $15/month Enterprise

• Basic ($5/month) — Flowise integration, identity nodes, service authentication
• Pro ($10/month) — Everything in Basic + advanced flow policies, custom node controls
• Enterprise ($15/month) — Everything in Pro + air-gapped deployment + white-label + compliance support

Volume discounts: 10-30% off for 5+ ACIs
Annual prepay: Additional 10-15% discount

Subscription Model: Monthly or annual billing via credit card. Stripe handles all payment processing. Integrate this package into your Flowise workflows and use in your applications. Access requires active subscription (validated per-request via EC2 authorization gateway at https://private.me/xbind/authorize).

API Purchase Endpoint

Programmatic subscription via REST API:

POST /api/purchase
Content-Type: application/json

{
  "product": "flowise",
  "tier": "basic",
  "email": "user@example.com"
}

Success Response

{
  "status": "success",
  "subscription_id": "sub_1TQvQXBMvV...",
  "tier": "basic",
  "trial_end": "2026-07-28T12:00:00Z",
  "billing_start": "2026-07-29T00:00:00Z"
}

Error Responses (RFC 7807)

{
  "type": "https://private.me/errors/validation-failed",
  "title": "Validation Failed",
  "status": 400,
  "detail": "Request validation failed",
  "instance": "/api/purchase/req-abc123",
  "fields": {
    "tier": "Must be 'basic', 'middle', or 'enterprise'",
    "email": "Invalid email format"
  }
}

xBind Identity Node

Generate cryptographic identity for workflows. Works standalone - no inputs required.

import { xBindIdentityNode } from '@private.me/flowise';

const node = new xBindIdentityNode({
  name: 'my-agent',
  description: 'Agent identity'
});

const output = await node.execute();
console.log(output.did); // did:key:z6Mkh...

Output Schema

{
  "did": "did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK",
  "identity": { "publicKey": Uint8Array, "secretKey": Uint8Array },
  "publicKeyJwk": { "kty": "OKP", "crv": "Ed25519", "x": "..." }
}

xBind Call Node

Call services with identity (no credentials needed). Requires identity input from xBindIdentityNode.

import { xBindCallNode } from '@private.me/flowise';

const node = new xBindCallNode({
  serviceName: 'payments',
  timeout: 30000,
  retries: 3
});

const result = await node.execute({
  identity: identityOutput.identity,
  payload: { amount: 100 }
});

Output Schema

{
  "success": true,
  "result": { "transactionId": "tx-123" },
  "timestamp": 1704067200000
}

xBind Message Node

Send or receive encrypted messages between agents. Supports both send and receive modes.

import { xBindMessageNode } from '@private.me/flowise';

const sendNode = new xBindMessageNode({ mode: 'send' });
const sendResult = await sendNode.execute({
  identity: identityOutput.identity,
  recipientDid: 'did:key:z6Mkh...',
  message: { task: 'process-data' }
});

const receiveNode = new xBindMessageNode({ mode: 'receive' });
const messages = await receiveNode.execute({
  identity: identityOutput.identity
});

Complete Workflow Patterns

Basic Service Call

[xBindIdentityNode]
        ↓
[xBindCallNode (serviceName: "payments")]
        ↓
Display result

Agent Communication

[xBindIdentityNode] ──────────┐
                              │
                    [xBindMessageNode (send)]
                    │
                    ├─ recipientDid: "did:key:z6Mkh..."
                    └─ message: { "task": "process-data" }
                              │
                    [Display: "Message sent!"]

Multi-Step Pipeline

      [xBindIdentityNode]
              ↓
      [xBindCallNode: fetch-data]
              ↓
      [xBindCallNode: process-data]
              ↓
      [xBindMessageNode: notify]
              ↓
      [Display results]

Core API

xBindIdentityNode

• constructor(options?) — Create identity node with optional name/description
• execute() — Generate cryptographic identity (async)
• Properties: name, description
• Output: { did, identity, publicKeyJwk }

xBindCallNode

• constructor(options) — Create call node with service configuration
• execute({ identity, payload }) — Call authenticated service
• Properties: serviceName (required), timeout (default: 30000), retries (default: 3)
• Output: { success, result?, error?, timestamp }

xBindMessageNode

• constructor(options) — Create message node with mode configuration
• execute(input) — Send or receive messages (mode-dependent)
• Properties: mode ("send" or "receive", default: "send"), timeout (default: 30000)
• Send Output: { success, messageId?, error?, timestamp }
• Receive Output: { success, messages[], error?, timestamp }

Node Configuration Properties

xBindIdentityNode

• name (optional) — Agent name for logging/debugging
• description (optional) — Node description in Flowise UI

xBindCallNode

• serviceName (required) — Service identifier to call
• timeout (optional) — Request timeout in milliseconds (default: 30000)
• retries (optional) — Retry attempts on failure (default: 3)

xBindMessageNode

• mode (optional) — "send" or "receive" (default: "send")
• timeout (optional) — Operation timeout in milliseconds (default: 30000)

Structured Error Responses

All nodes return structured error responses instead of throwing exceptions. Workflows continue on individual failures.

{
  "success": false,
  "error": "Description of what failed",
  "timestamp": 1704067200000
}

Common error scenarios:

• Missing required fields — "identity is required" / "serviceName is required"
• Network failures — Automatic retries with exponential backoff (configurable)
• Service unavailable — Error message includes retry-after information
• Invalid DID format — Validation error with expected format

Real-World Use Cases

LLM Orchestration

Chain multiple LLM calls with identity-based authentication. Each step uses cryptographic identity instead of shared API keys.

No-Code Automation

Build complex automation workflows without managing credentials. Non-technical users can connect services securely via drag-and-drop.

Multi-Agent Systems

Coordinate multiple agents with encrypted message passing. Each agent has unique cryptographic identity for secure communication.