Welcome to White Rabbit

White Rabbit is a crypto workflow automation platform that lets you build, automate, and scale on-chain operations without writing infrastructure code.

Design multi-step workflows on a visual canvas — connect blockchain protocols, APIs, and smart contracts with typed ports. Execute them on-demand via API, on a schedule, or triggered by a webhook.

What can you build?

Use case	Key components
Token swap automation	`GET_UNISWAP_SWAP_QUOTE` → `BUILD_EVM_UNISWAP_SWAP_CALLDATA` → `BROADCAST_EVM_TRANSACTION`
Safe treasury management	`BUILD_EVM_GNOSIS_SAFE_DEPLOYMENT` → `BUILD_EVM_SAFE_SIGNATURE` → `SIGN_WITH_KEY_SHARE`
On-chain data pipelines	`READ_EVM_CONTRACT` → `DECODE_EVM_FUNCTION_RESULT` → `API_CALL`
Key generation workflows	`GENERATE_KEY_SHARE` → `COMPUTE_PUBLIC_KEY` → `COMPUTE_EVM_ADDRESS`
Multi-chain batch processing	`FOR_EACH` → `BUILD_EVM_TRANSACTION` → `SIGN_EVM_TRANSACTION`

How it works

Trigger (API call / webhook / schedule)
        │
        ▼
┌───────────────────────────────────────────────┐
│               Workflow Engine                  │
│                                               │
│  Component A ──▶ Component B ──▶ Component C  │
│       │                                       │
│       └──▶ FOR_EACH ──▶ Component D (×N)      │
└───────────────────────────────────────────────┘
        │
        ▼
Result + stage-by-stage breakdown (SSE stream)

Define — drag components onto a canvas, connect ports, configure parameters.
Trigger — call POST /v1/sdk/workflows with your workflow API key.
Stream — subscribe to GET /v1/sdk/workflows/executions/:id/stream for live status.
Inspect — view every stage's output, credit usage, and execution time.

Key concepts

Components

Self-contained executable units. Each component has typed inputs, typed outputs, and optional config fields. Components communicate results downstream via typed data connections.

→ Browse the component library

Workflows

Directed graphs of components connected by sequence edges (control flow) and data connections (typed values). The workflow engine executes the DAG, handling parallelism and iteration automatically.

Workspace

Your isolated tenant. Holds workflows, environment variables, members, an API key, and a credit balance. All API calls are scoped to a workspace.

Credits

The unit of consumption. Each component reports its credit cost (billing.amount). Credits are deducted after a run finalizes. Unused plan credits reset on a schedule.

→ See plan and rate-limit docs for details.

Getting started in 5 minutes

1. Get your API key

Go to Dashboard → Workspace → Settings → API Key and copy your workspace API key.

2. Execute a component

The easiest way is via the TypeScript SDK — it handles request signing automatically:

import { WorkspaceClient, ComponentModule } from 'caller-sdk';

const workspace = new WorkspaceClient({ apiKey: process.env.WR_API_KEY! });

const result = await workspace.call(ComponentModule.RANDOM_UUID, {}).promise();
console.log(result.uuid); // "a4c2e8f1-39b0-4d7a-83c6-1b5f2e9d0c77"

REST API requires request signing

Direct REST calls require three headers: your API key, a Unix timestamp (X-Sdk-Timestamp), and an Ed25519 signature (X-Sdk-Signature). See Authentication → for the signing implementation. The TypeScript SDK handles this automatically.

Without waitForMs, POST /v1/sdk/components returns immediately with status: "CREATED" — the component runs asynchronously. Use .promise() (SSE-backed) or poll GET /executions/:id to retrieve the result.

3. Execute a workflow

const res = await fetch('https://api.whiterabbit.app/v1/sdk/workflows/<workflowId>', {
  method: 'POST',
  headers: {
    'X-Api-Key': process.env.WR_API_KEY!,
    'X-Sdk-Timestamp': String(Math.floor(Date.now() / 1000)),
    // X-Sdk-Signature: <Ed25519 signature> — see Authentication docs
  },
});
const { runId } = await res.json();

4. Stream the run status

const source = new EventSource(
  `https://api.whiterabbit.app/v1/sdk/workflows/executions/${runId}/stream`,
  { headers: { 'X-Api-Key': process.env.WR_API_KEY! } },
);
source.onmessage = (e) => {
  const update = JSON.parse(e.data);
  if (update.status === 'COMPLETED' || update.status === 'FAILED') source.close();
};

data: {"id":"9e4c...","status":"EXECUTING","output":{"pendingStageCount":3}}
data: {"id":"9e4c...","status":"EXECUTING","output":{"pendingStageCount":2}}
data: {"id":"9e4c...","status":"COMPLETED","output":{"totalUsage":14}}

Plans

Plan	Monthly credits	Rate limit	Usage limit
Starter	0 (pay-as-you-go)	5 req/s	—
Growth	200 / month	10 req/s	500 / month
Professional	1,000 / month	25 req/s	2,500 / month
Enterprise	Custom	Custom	Custom

Rate limits are always enforced regardless of credit balance.
Usage limits gate only when your credit balance is zero — paid credits are unlimited.
Credits reset weekly (soft) and monthly (hard).

Next steps

SDK Quickstart → Execute components and workflows from code.

Authentication → API keys, scopes, and signing.

Streaming → Real-time SSE status updates.

Component Library → All 40+ components with schemas.

What can you build?​

How it works​

Key concepts​

Components​

Workflows​

Workspace​

Credits​

Getting started in 5 minutes​

1. Get your API key​

2. Execute a component​

3. Execute a workflow​

4. Stream the run status​

Plans​

Next steps​