API Reference

All methods are available in both TypeScript and Python SDKs. TypeScript uses camelCase, Python uses snake_case.

Nodes

Read and write node data in the workflow.

`nodes.getOutput(nodeId)`

Read a node’s last execution output. Returns whatever exists, which may be from a cron run, manual execution, or webhook trigger.

const output = await nodes.getOutput('node-id');
// Returns the node's output object, or null if never executed

output = await sdk.nodes.get_output("node-id")

`nodes.getConfig(nodeId)`

Read a node’s configuration fields.

const config = await nodes.getConfig('node-id');
// { action: 'read', max_results: 20, ... }

config = await sdk.nodes.get_config("node-id")

`nodes.setConfig(nodeId, config)`

Set configuration fields on a node (merges with existing config).

await nodes.setConfig('http-node', { url: 'https://api.example.com' });

# Not yet supported in Python SDK (use nodes directly in workflow)

`nodes.list()`

List all nodes in the workflow.

const allNodes = await nodes.list();
// [{ id, type, label, hasOutput }, ...]

nodes = await sdk.nodes.list()
# [{"id": "...", "type": "...", "label": "...", "hasOutput": False}, ...]

Execution

Run nodes and track results.

`execution.runNodesAndGetOutput(runNodes, targetNodes)`

Run nodes and stream output as each target node completes. Parameters:

runNodes: nodes to execute. String IDs or { id, config } objects with temporary config overrides.
targetNodes: node IDs whose output to collect.

const stream = execution.runNodesAndGetOutput(
  ['data-fetcher'],           // run these
  ['chart-data', 'summary']   // collect output from these
);

stream.on('output', (nodeId, data) => { /* fires per target */ });
stream.on('error', (nodeId, error) => { /* target errored */ });
stream.on('done', () => { /* all targets completed */ });

// Or await all at once
const results = await stream.all();
// { 'chart-data': {...}, 'summary': {...} }

results = await sdk.execution.run_nodes_and_get_output(
    ["data-fetcher"],
    ["chart-data", "summary"],
    timeout=30,
)
# {"chart-data": {...}, "summary": {...}}

With config overrides (temporary, doesn’t save):

execution.runNodesAndGetOutput(
  [{ id: 'http-node', config: { url: userInput } }],
  ['http-node']
);

`execution.runNodesInBackground(runNodes)`

Fire-and-forget execution. Returns immediately.

execution.runNodesInBackground(['data-fetcher']);

// With config overrides
execution.runNodesInBackground([
  { id: 'llm-node', config: { prompt: 'Summarize Q4 report' } }
]);

await sdk.execution.run_nodes_in_background(["data-fetcher"])

`execution.stop()`

Stop the current workflow execution.

`execution.onNodeState(nodeId, handler)`

Subscribe to a node’s execution state changes. Works for any trigger (manual, cron, webhook).

const unsub = execution.onNodeState('node-id', (state) => {
  // 'idle' | 'running' | 'completed' | 'error'
});
unsub(); // unsubscribe

`execution.onNodeOutput(nodeId, handler)`

Subscribe to a node’s output in real-time. Fires whenever the node produces output, from any source.

const unsub = execution.onNodeOutput('data-node', (output) => {
  console.log('New data:', output);
});

State

Persistent key-value storage via state-manager nodes. Requires a State Manager node in the workflow.

`state.get(key)`

const val = await state.get('counter');
// Returns the value, or undefined if not set

val = await sdk.state.get("counter")

`state.set(key, value)`

await state.set('counter', 42);
await state.set('user', { name: 'Alice', score: 95 });

await sdk.state.set("counter", 42)

`state.del(key)`

Remove a key entirely.

await state.del('counter');

await sdk.state.delete("counter")

`state.update(key, updater)`

Read-modify-write with an updater function. The function runs locally (not on the server).

await state.update('counter', n => (n || 0) + 1);
await state.update('items', list => [...(list || []), newItem]);
await state.update('profile', p => ({ ...p, lastSeen: Date.now() }));

`state.keys()`

List all available state keys.

const keys = await state.keys(); // ['counter', 'items', ...]

keys = await sdk.state.keys()

`state.onChange(key, handler)`

Subscribe to state changes. Fires on set and del from any source.

state.onChange('counter', (newVal) => {
  console.log('Counter changed:', newVal);
});

Auth

Credential management and OAuth flows.

`auth.listCredentials()`

List all available credentials for the user.

const creds = await auth.listCredentials();
// [{ id, type, name }, ...]

creds = await sdk.auth.list_credentials()

`auth.hasCredential(credentialType)`

Check if a credential of the given type exists.

const has = await auth.hasCredential('google_gmail_oauth'); // true/false

has = await sdk.auth.has_credential("google_gmail_oauth")

`auth.requestCredential(credentialType)`

Only available in custom components (iframe context). Opens the NoClick OAuth popup.

Trigger an OAuth flow. Scopes are automatically resolved from node schemas.

const cred = await auth.requestCredential('google_gmail_oauth');
// { id, type, name } or null if user cancelled

`auth.createCredential(credentialType, data, name?)`

Create a non-OAuth credential (API key, token, etc). The component provides its own input UI.

const cred = await auth.createCredential('telegram_bot_token', {
  token: apiKey
}, 'My Bot');

cred = await sdk.auth.create_credential("telegram_bot_token", {"token": key}, "My Bot")

Resources

File and blob storage via R2. Scoped to the workflow.

`resources.upload(name, mimeType, sizeBytes)`

Create a resource and get a presigned upload URL. PUT the file body to the URL.

const { resourceId, uploadUrl } = await resources.upload('photo.jpg', 'image/jpeg', file.size);
await fetch(uploadUrl, { method: 'PUT', body: file });

result = await sdk.resources.upload("photo.jpg", "image/jpeg", file_size)
# PUT file to result["upload_url"]

`resources.getUrl(resourceId)`

Get a presigned download URL.

const url = await resources.getUrl(resourceId);

url = await sdk.resources.get_url(resource_id)

`resources.list(resourceType?)`

List resources in the workflow. Optionally filter by type ('file', 'image', 'dataset', etc).

`resources.remove(resourceId)`

Delete a resource and its stored data.

Dataset

Tabular data with CRUD operations. Backed by PostgreSQL, scalable for large datasets. Rows are schemaless JSONB.

`dataset.create(name)`

Create a new dataset. Returns the resource ID.

const resourceId = await dataset.create('User Submissions');

resource_id = await sdk.dataset.create("User Submissions")

`dataset.list()`

List all datasets in the workflow.

const datasets = await dataset.list();
// [{ id, name, rowCount }, ...]

datasets = await sdk.dataset.list()

`dataset.appendRows(resourceId, rows)`

Append rows to a dataset. Each row is an arbitrary JSON object.

await dataset.appendRows(resourceId, [
  { name: 'Alice', score: 95 },
  { name: 'Bob', score: 87 },
]);

count = await sdk.dataset.append_rows(resource_id, [
    {"name": "Alice", "score": 95},
    {"name": "Bob", "score": 87},
])

`dataset.getRows(resourceId, options?)`

Get paginated rows from a dataset.

const page = await dataset.getRows(resourceId, { limit: 100, offset: 0 });
// { rows: [{ id, data, created_at, updated_at }], totalCount: 1000 }

page = await sdk.dataset.get_rows(resource_id, limit=100, offset=0)
# {"rows": [...], "total_count": 1000}

`dataset.updateRow(resourceId, rowId, data)`

Update a single row’s data.

`dataset.deleteRows(resourceId, rowIds)`

Delete rows by their UUIDs.

Workflow

`workflow.getInfo()`

Get information about the current workflow.

const info = await workflow.getInfo();
// { id, name, nodeCount }

info = await sdk.workflow.get_info()

`workflow.nodeId` (TypeScript only)

The current component’s node ID. Set automatically in iframe context.

import { workflow } from '@noclick/sdk';
console.log(workflow.nodeId);

​API Reference

​Nodes

​nodes.getOutput(nodeId)

​nodes.getConfig(nodeId)

​nodes.setConfig(nodeId, config)

​nodes.list()

​Execution

​execution.runNodesAndGetOutput(runNodes, targetNodes)

​execution.runNodesInBackground(runNodes)

​execution.stop()

​execution.onNodeState(nodeId, handler)

​execution.onNodeOutput(nodeId, handler)

​State

​state.get(key)

​state.set(key, value)

​state.del(key)

​state.update(key, updater)

​state.keys()

​state.onChange(key, handler)

​Auth

​auth.listCredentials()

​auth.hasCredential(credentialType)

​auth.requestCredential(credentialType)

​auth.createCredential(credentialType, data, name?)

​Resources

​resources.upload(name, mimeType, sizeBytes)

​resources.getUrl(resourceId)

​resources.list(resourceType?)

​resources.remove(resourceId)

​Dataset

​dataset.create(name)

​dataset.list()

​dataset.appendRows(resourceId, rows)

​dataset.getRows(resourceId, options?)

​dataset.updateRow(resourceId, rowId, data)

​dataset.deleteRows(resourceId, rowIds)

​Workflow

​workflow.getInfo()

​workflow.nodeId (TypeScript only)

API Reference

Nodes

`nodes.getOutput(nodeId)`

`nodes.getConfig(nodeId)`

`nodes.setConfig(nodeId, config)`

`nodes.list()`

Execution

`execution.runNodesAndGetOutput(runNodes, targetNodes)`

`execution.runNodesInBackground(runNodes)`

`execution.stop()`

`execution.onNodeState(nodeId, handler)`

`execution.onNodeOutput(nodeId, handler)`

State

`state.get(key)`

`state.set(key, value)`

`state.del(key)`

`state.update(key, updater)`

`state.keys()`

`state.onChange(key, handler)`

Auth

`auth.listCredentials()`

`auth.hasCredential(credentialType)`

`auth.requestCredential(credentialType)`

`auth.createCredential(credentialType, data, name?)`

Resources

`resources.upload(name, mimeType, sizeBytes)`

`resources.getUrl(resourceId)`

`resources.list(resourceType?)`

`resources.remove(resourceId)`

Dataset

`dataset.create(name)`

`dataset.list()`

`dataset.appendRows(resourceId, rows)`

`dataset.getRows(resourceId, options?)`

`dataset.updateRow(resourceId, rowId, data)`

`dataset.deleteRows(resourceId, rowIds)`

Workflow

`workflow.getInfo()`

`workflow.nodeId` (TypeScript only)