Neonloops API

Authentication

All API requests require a Bearer token in the Authorization header. API keys start with nl_sk_ and can be created from your Dashboard.

curl -X POST https://neonloops.com/api/v1/run \
  -H "Authorization: Bearer nl_sk_xxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "workflow_id": "wf_abc123",
    "input": [{"role": "user", "content": "Hello"}]
  }'

Execute a workflow synchronously. The response is returned after the workflow completes.

Request Body

{
  "workflow_id": "wf_abc123",
  "input": [
    { "role": "user", "content": "Summarize the latest news" }
  ],
  "session_id": "sess_xyz",
  "variables": {
    "language": "en",
    "max_length": 500
  }
}

{
  "id": "run_k7m2n9p4",
  "workflow_id": "wf_abc123",
  "status": "completed",
  "output": "Here is a summary of...",
  "error": null,
  "metadata": {
    "tokens": { "input": 42, "output": 128 },
    "durationMs": 3200,
    "nodesExecuted": ["start", "llm_1", "end"]
  }
}

Response Headers

Status Codes

{
  "id": "run_k7m2n9p4",
  "workflow_id": "wf_abc123",
  "status": "pending_approval",
  "approval_prompt": "Deploy to production?",
  "paused_at_node_id": "approval-1",
  "output": null,
  "metadata": {
    "durationMs": 1200,
    "nodesExecuted": ["start", "llm_1", "approval-1"]
  }
}

Execute a workflow with real-time Server-Sent Events (SSE). Receive granular updates as each node executes. Request body is the same as /api/v1/run.

Event Types

Event Payloads

{ "type": "run:start", "runId": "run_k7m2n", "totalNodes": 5 }

{ "type": "node:start", "runId": "run_k7m2n",
  "nodeId": "llm_1", "nodeType": "llm", "nodeLabel": "Summarizer" }

{ "type": "node:complete", "runId": "run_k7m2n",
  "nodeId": "llm_1", "nodeType": "llm", "nodeLabel": "Summarizer",
  "durationMs": 1200, "outputPreview": "Here is...",
  "tokenUsage": { "input": 42, "output": 128 } }

{ "type": "node:error", "runId": "run_k7m2n",
  "nodeId": "llm_1", "nodeType": "llm", "error": "Provider timeout" }

{ "type": "node:text-delta", "runId": "run_k7m2n",
  "nodeId": "llm_1", "nodeType": "agent", "nodeLabel": "Summarizer",
  "delta": "Here" }

{ "type": "node:waiting_approval", "runId": "run_k7m2n",
  "nodeId": "approval_1", "nodeType": "approval",
  "nodeLabel": "Review", "approvalPrompt": "Deploy to production?" }

{ "type": "edge:traversed", "runId": "run_k7m2n",
  "edgeId": "e1-2", "source": "llm_1", "target": "llm_2" }

{ "type": "fan-out", "runId": "run_k7m2n",
  "sourceNodeId": "router_1", "targetCount": 3 }

{ "type": "fan-in:waiting", "runId": "run_k7m2n",
  "nodeId": "merge_1", "arrived": 2, "expected": 3 }

{ "type": "fan-in:ready", "runId": "run_k7m2n", "nodeId": "merge_1" }

{ "type": "run:paused", "runId": "run_k7m2n",
  "pausedAtNodeId": "approval_1", "durationMs": 800 }

{ "type": "run:resumed", "runId": "run_k7m2n" }

{ "type": "run:complete", "runId": "run_k7m2n",
  "status": "completed", "durationMs": 3200 }

{ "type": "run:result", "id": "run_k7m2n", "workflow_id": "wf_abc123",
  "status": "completed", "output": "Here is a summary...", "error": null,
  "metadata": { "tokens": { "input": 42, "output": 128 },
    "durationMs": 3200, "nodesExecuted": ["start", "llm_1", "end"] } }

event: run:start
data: {"type":"run:start","runId":"run_k7m2n","totalNodes":3}

event: node:start
data: {"type":"node:start","runId":"run_k7m2n","nodeId":"llm_1","nodeType":"agent","nodeLabel":"Summarizer"}

data: {"type":"node:text-delta","runId":"run_k7m2n","nodeId":"llm_1","nodeType":"agent","nodeLabel":"Summarizer","delta":"Here"}
data: {"type":"node:text-delta","runId":"run_k7m2n","nodeId":"llm_1","nodeType":"agent","nodeLabel":"Summarizer","delta":" is"}
data: {"type":"node:text-delta","runId":"run_k7m2n","nodeId":"llm_1","nodeType":"agent","nodeLabel":"Summarizer","delta":" a summary"}

event: node:complete
data: {"type":"node:complete","runId":"run_k7m2n","nodeId":"llm_1","durationMs":1200,"outputPreview":"Here is a summary..."}

event: run:complete
data: {"type":"run:complete","runId":"run_k7m2n","status":"completed","durationMs":3200}

event: run:result
data: {"type":"run:result","id":"run_k7m2n","status":"completed","output":"Here is a summary..."}

const res = await fetch("/api/v1/run/stream", {
  method: "POST",
  headers: {
    "Authorization": "Bearer nl_sk_xxxxx",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    workflow_id: "wf_abc123",
    input: [{ role: "user", content: "Summarize the news" }],
  }),
});

const reader = res.body!
  .pipeThrough(new TextDecoderStream())
  .getReader();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  console.log(value);
}

Versioning & Rollback

Every time you publish a workflow, an immutable snapshot is saved. You can pin API runs to a specific version or roll back to a previous one.

Get the full snapshot for a specific version, including nodes and edges.

Roll back a workflow to a previous version. Rollback does not delete or overwrite existing versions — it copies the target snapshot's nodes/edges and publishes it as a new version, preserving the full version history. Status is set to live.

// Pin a run to version 2
const result = await runner.run("wf_abc123", {
  input: [{ role: "user", content: "Hello!" }],
  version: 2,
});

// Inspect a specific version's definition
const v2 = await runner.workflows.getVersion("wf_abc123", 2);
console.log(v2.nodes, v2.edges);

// Roll back to version 2 (publishes as a new version)
const rollback = await runner.workflows.rollback("wf_abc123", 2);
console.log(rollback.version); // e.g. 5 (new version number)

# Pin a run to version 2
result = runner.run_sync(
    "wf_abc123",
    input=[RunInput(role="user", content="Hello!")],
    version=2,
)

# Inspect a specific version's definition
v2 = runner.workflows.get_version_sync("wf_abc123", 2)
print(v2.nodes, v2.edges)

# Roll back to version 2 (publishes as a new version)
rollback = runner.workflows.rollback_sync("wf_abc123", 2)
print(rollback.version)  # e.g. 5 (new version number)

Approval Workflows

Workflows containing a Human Approval node pause execution and return a 202 response with status pending_approval. Use the approve or reject endpoints to resume execution.

Resume the workflow along the approved path. Returns the final result, or another 202 if the workflow hits another approval node.

Resume the workflow along the rejected path. If no rejection edge exists, the run fails with "Approval rejected".

Status Codes

import { Runner, createInput } from "@neonloops/sdk";

const runner = new Runner({ apiKey: "nl_sk_xxxxx" });

// Execute workflow
const result = await runner.run("wf_abc123", {
  input: [createInput("user", "Deploy v2.1 to production")],
});

// Check if approval is needed
if (result.status === "pending_approval") {
  console.log(result.approvalPrompt);

  // Approve with optional comment
  const final = await runner.approve(result.id, {
    comment: "Looks good, ship it!",
  });
  console.log(final.output);

  // Or reject it
  // const final = await runner.reject(result.id, {
  //   comment: "Needs more testing",
  // });
}

from neonloops import Runner, RunInput

runner = Runner(api_key="nl_sk_xxxxx")

# Execute workflow
result = runner.run_sync(
    "wf_abc123",
    input=[RunInput(role="user", content="Deploy v2.1")],
)

# Check if approval is needed
if result.status == "pending_approval":
    print(result.approval_prompt)

    # Approve with optional comment
    final = runner.approve_sync(
        result.id, comment="Looks good, ship it!"
    )
    print(final.output)

    # Or reject it
    # final = runner.reject_sync(
    #     result.id, comment="Needs more testing"
    # )

Sessions

Create and manage chat sessions for multi-turn conversations. When a session_id is passed to /api/v1/run, the server automatically loads previous messages from the session.

Create a new chat session for a workflow.

List sessions for a workflow, ordered by most recently updated.

Get messages in a session, in chronological order.

{
  "id": "sess_abc123",
  "workflow_id": "wf_abc123",
  "title": "New chat",
  "created_at": "2026-01-15T10:30:00.000Z"
}

{
  "data": [
    {
      "id": "msg_001",
      "session_id": "sess_abc123",
      "role": "user",
      "content": "What is 2+2?",
      "type": "text",
      "created_at": "2026-01-15T10:30:00.000Z"
    }
  ],
  "pagination": {
    "total": 24,
    "limit": 100,
    "offset": 0,
    "has_more": false
  }
}

Multi-turn Conversation

import { Runner, createInput } from "@neonloops/sdk";

const runner = new Runner({ apiKey: "nl_sk_xxxxx" });

// 1. Create a session
const session = await runner.createSession("wf_abc123");

// 2. First message
const r1 = await runner.run("wf_abc123", {
  input: [createInput("user", "My name is Alice")],
  sessionId: session.id,
});

// 3. Follow-up — only send the new message
const r2 = await runner.run("wf_abc123", {
  input: [createInput("user", "What's my name?")],
  sessionId: session.id,
});

console.log(r2.output); // "Your name is Alice"

// List sessions for this workflow
const sessions = await runner.listSessions("wf_abc123");

// Get message history
const messages = await runner.getSessionMessages(session.id);

from neonloops import Runner, RunInput

runner = Runner(api_key="nl_sk_xxxxx")

# 1. Create a session
session = runner.create_session_sync("wf_abc123")

# 2. First message
r1 = runner.run_sync(
    "wf_abc123",
    input=[RunInput(role="user", content="My name is Alice")],
    session_id=session.id,
)

# 3. Follow-up — only send the new message
r2 = runner.run_sync(
    "wf_abc123",
    input=[RunInput(role="user", content="What's my name?")],
    session_id=session.id,
)

print(r2.output)  # "Your name is Alice"

# List sessions for this workflow
sessions = runner.list_sessions_sync("wf_abc123")

# Get message history
messages = runner.get_session_messages_sync(session.id)

Expressions

Neonloops uses CEL (Common Expression Language) for dynamic logic inside workflows. Expressions power Condition branches, Transform field mappings, SetState variable mutations, and WhileLoop conditions.

Neonloops implements the CEL specification (google.github.io/cel-spec). Standard CEL operators, types, and functions are fully supported. The functions listed in the Custom Functions table below are Neonloops-specific extensions — they are not part of the CEL standard and are only available inside Neonloops workflows.

There are two expression modes:

Expression Context

Before any expression is evaluated, the execution context is flattened— all variables and the previous node's output are merged into a single root scope so you can access them directly by name.

// State before evaluation:
// variables:  { name: "Alice", age: 30 }
// lastOutput: { score: 95, status: "ok" }

// Flattened context — all of these are directly accessible:
name     → "Alice"                         // from variables
age      → 30                              // from variables
score    → 95                              // from lastOutput (spread)
status   → "ok"                            // from lastOutput (spread)
output   → { score: 95, status: "ok" }     // lastOutput itself
output.score → 95                          // dot access on output

variables:  { status: "pending" }
lastOutput: { status: "approved" }

status        → "approved"   // lastOutput overwrites the variable
output.status → "approved"   // always safe for lastOutput fields

lastOutput Types

The previous node's output can be different types depending on the node:

CEL Syntax Reference

Operators

String Methods

List & Map Operations

Template Interpolation

Use ${var} or {{var}} markers to substitute values into strings. Both syntaxes are interchangeable.

// Multiple markers → always returns a string
${firstName} ${lastName}          → "Ada Lovelace"
{{name}}: score={{score}}          → "Alice: score=95"

// Single block → unwrapped to raw value (not stringified)
{{age + 1}}                        → 29 (number)
{{user}}                           → { name: "Alice", ... } (object)

// Missing values are replaced with empty string
Hello ${unknown}!                  → "Hello !"

Node Usage Examples

Condition Node

Each branch has a CEL expression that must return true or false. The first branch that evaluates to true is taken.

// Branch "Adult"
age >= 18

// Branch "VIP Customer"
order_count > 10 && membership == "gold"

// Branch "Urgent Support"
urgency == "high" && sentiment == "angry"

// Branch "Contains keyword"
output.contains("refund") || output.contains("cancel")

Transform Node

Each row maps a key to a CEL expression. The result is a new object with the computed values.

// key: full_name
first_name + " " + last_name

// key: is_adult
age >= 18

// key: greeting
"Hello " + name.upperAscii()

// key: word_count
wordCount(output)

SetState Node

Each row assigns the result of a CEL expression to a workflow variable.

// variable: retry_count
retry_count + 1

// variable: status
output.status

// variable: total_score
total_score + score

// variable: last_error
output.contains("error") ? output : last_error

WhileLoop Node

A single CEL expression that controls the loop — the loop body executes as long as the expression returns true.

// Retry until success or max retries
retry_count < max_retries && !success

// Improve until quality threshold
score < 80 && iteration < 5

// Process until list is empty
size(remaining_items) > 0

Fan-In Expressions

When a node receives input from multiple parallel branches (fan-in), lastOutput is a special FanInInput object with outputs from each branch keyed by source node ID.

{
  "_fanIn": true,
  "branches": {
    "n8":  { "approve": true,  "reason": "Well written" },
    "n9":  { "approve": false, "reason": "Needs sources" },
    "n10": { "approve": true,  "reason": "Great work" }
  }
}

Access branch outputs using branches.nodeId.field — thanks to context flattening, branches is directly accessible.

// Vote counting — majority approval (2 of 3 reviewers)
(branches.n8.approve ? 1 : 0) + (branches.n9.approve ? 1 : 0) + (branches.n10.approve ? 1 : 0) >= 2

// Access individual branch values
branches.n8.reason                    → "Well written"

// Check if specific branches approved
branches.n8.approve && branches.n10.approve

// Missing branch is safe (no error)
branches.n99.field                    → undefined

// Combine reviews into a summary string
Review 1: {{branches.n8.reason}}, Review 2: {{branches.n9.reason}}, Review 3: {{branches.n10.reason}}

Workflows

Manage workflows programmatically — list, create, update, delete, publish, and inspect run history.

List Workflows

List Versions

List Runs

Create Workflow

Update Workflow

Publish Workflow

Creates a new immutable version snapshot. Optionally override nodes and edges at publish time.

[
  {
    "id": "wf_abc123",
    "project_id": "proj_xyz",
    "name": "Customer Support Bot",
    "description": "Handles tier-1 support tickets",
    "version": 3,
    "status": "live",
    "created_at": "2026-01-10T08:00:00.000Z",
    "updated_at": "2026-01-15T14:30:00.000Z"
  }
]

{
  "version": 4,
  "status": "live"
}

{
  "id": "run_k7m2n9p4",
  "workflow_id": "wf_abc123",
  "status": "completed",
  "output": "Ticket resolved.",
  "error": null,
  "workflow_version": 3,
  "input": [{ "role": "user", "content": "My order is late" }],
  "metadata": {
    "tokens": { "input": 85, "output": 210 },
    "durationMs": 4500,
    "nodesExecuted": ["start", "classify", "llm_1", "end"]
  },
  "node_trace": [...],
  "started_at": "2026-01-15T14:30:00.000Z",
  "completed_at": "2026-01-15T14:30:04.500Z",
  "created_at": "2026-01-15T14:30:00.000Z"
}

SDK Examples

import { Runner } from "@neonloops/sdk";

const runner = new Runner({ apiKey: "nl_sk_xxxxx" });

// List workflows
const workflows = await runner.workflows.list({
  projectId: "proj_xyz",
  limit: 10,
});

// Get a single workflow (includes nodes, edges, settings)
const detail = await runner.workflows.get("wf_abc123");

// Create a workflow
const wf = await runner.workflows.create({
  name: "My Workflow",
  projectId: "proj_xyz",
});

// Update it
await runner.workflows.update(wf.id, {
  name: "Renamed Workflow",
});

// Publish
const pub = await runner.workflows.publish(wf.id);
console.log("Published version:", pub.version);

// List versions and runs
const versions = await runner.workflows.listVersions(wf.id);
const runs = await runner.workflows.listRuns(wf.id);
const run = await runner.workflows.getRun(wf.id, runs[0].id);

// Delete
await runner.workflows.delete(wf.id);

from neonloops import Runner

runner = Runner(api_key="nl_sk_xxxxx")

# List workflows
workflows = runner.workflows.list_sync(
    project_id="proj_xyz",
    limit=10,
)

# Get a single workflow (includes nodes, edges, settings)
detail = runner.workflows.get_sync("wf_abc123")

# Create a workflow
wf = runner.workflows.create_sync(
    name="My Workflow",
    project_id="proj_xyz",
)

# Update it
runner.workflows.update_sync(wf.id, name="Renamed Workflow")

# Publish
pub = runner.workflows.publish_sync(wf.id)
print("Published version:", pub.version)

# List versions and runs
versions = runner.workflows.list_versions_sync(wf.id)
runs = runner.workflows.list_runs_sync(wf.id)
run = runner.workflows.get_run_sync(wf.id, runs[0].id)

# Delete
runner.workflows.delete_sync(wf.id)

Projects

Projects group workflows and secrets together. API keys can be scoped to a single project for isolation.

List Projects

Create / Update Project

{
  "id": "proj_xyz",
  "name": "Production",
  "enabled": true,
  "created_at": "2026-01-10T08:00:00.000Z",
  "updated_at": "2026-01-10T08:00:00.000Z"
}

// List projects
const projects = await runner.projects.list();

// Create
const proj = await runner.projects.create({
  name: "Staging",
});

// Update
await runner.projects.update(proj.id, {
  name: "Staging v2",
  enabled: false,
});

// Delete
await runner.projects.delete(proj.id);

# List projects
projects = runner.projects.list_sync()

# Create
proj = runner.projects.create_sync(name="Staging")

# Update
runner.projects.update_sync(
    proj.id, name="Staging v2", enabled=False
)

# Delete
runner.projects.delete_sync(proj.id)

Secrets

Store API keys and sensitive values that workflows can access at runtime. Secrets exist at two levels — project and workflow — with workflow secrets overriding project secrets.

Project Secrets

Workflow Secrets

Create Secret

[
  {
    "id": "sec_abc123",
    "name": "OPENAI_API_KEY",
    "created_at": "2026-01-10T08:00:00.000Z"
  }
]

{
  "id": "sec_abc123",
  "name": "OPENAI_API_KEY"
}

SDK Examples

// Project secrets
const secrets = await runner.projects.secrets.list("proj_xyz");

await runner.projects.secrets.create("proj_xyz", {
  name: "OPENAI_API_KEY",
  value: "sk-...",
});

await runner.projects.secrets.delete("proj_xyz", "sec_abc123");

// Workflow secrets (override project secrets)
await runner.workflows.secrets.create("wf_abc123", {
  name: "OPENAI_API_KEY",
  value: "sk-override-...",
});

const wfSecrets = await runner.workflows.secrets.list("wf_abc123");

await runner.workflows.secrets.delete("wf_abc123", "sec_xyz");

# Project secrets
secrets = runner.projects.secrets.list_sync("proj_xyz")

runner.projects.secrets.create_sync(
    "proj_xyz",
    name="OPENAI_API_KEY",
    value="sk-...",
)

runner.projects.secrets.delete_sync("proj_xyz", "sec_abc123")

# Workflow secrets (override project secrets)
runner.workflows.secrets.create_sync(
    "wf_abc123",
    name="OPENAI_API_KEY",
    value="sk-override-...",
)

wf_secrets = runner.workflows.secrets.list_sync("wf_abc123")

runner.workflows.secrets.delete_sync("wf_abc123", "sec_xyz")

Error Handling

All errors follow a consistent JSON format with an error code, human-readable message, and a unique request ID for debugging.

{
  "error": {
    "code": "WORKFLOW_NOT_FOUND",
    "message": "The specified workflow does not exist",
    "request_id": "req_a1b2c3d4"
  }
}

Rate Limiting & Quotas

API usage is subject to rate limits and monthly quotas based on your plan.

Response Headers

When rate limited, use the Retry-After header with exponential backoff to retry requests gracefully.

Pagination

All list endpoints support pagination via limit and offset query parameters.

Session endpoints wrap results in a data array with a pagination object. Use has_more to determine if more pages are available.

{
  "data": [...],
  "pagination": {
    "total": 142,
    "limit": 50,
    "offset": 0,
    "has_more": true
  }
}

Other list endpoints (workflows, projects, secrets, versions, runs) return a bare JSON array. These endpoints still accept limit and offset query parameters to control pagination.

[
  { "id": "wf_abc123", "name": "My Workflow", ... },
  { "id": "wf_def456", "name": "Another Workflow", ... }
]

curl https://neonloops.com/api/v1/sessions?workflow_id=wf_abc123&limit=50&offset=50 \
  -H "Authorization: Bearer nl_sk_xxxxx"

Type Reference

Core types used across the API and SDKs. TypeScript names are shown first, followed by Python equivalents where different.

Execution Types

Resource Types

Streaming Event Types

In TypeScript, use the StreamEvent union type. In Python, use StreamEventUnion and the parse_stream_event() helper for type-safe event handling.

Audit Logging

Neonloops automatically logs administrative actions for accountability. Audit logs are attached to the authenticated user and include the action, resource type, and resource ID.

Audit logs are retained for 90 days and are accessible from the Dashboard. Read-only operations (list, get) on workflows and projects are not logged.

Approval and rejection comments submitted via the /approve and /reject endpoints are persisted as part of the run record and are not stored in audit logs.

SDKs

Official client libraries for TypeScript and Python. Both SDKs wrap the REST API with typed interfaces, automatic retries, and streaming support.

Installation

npm install @neonloops/sdk

pip install neonloops

Configuration

Create a Runner instance with your API key and optional settings.

import { Runner } from "@neonloops/sdk";

const runner = new Runner({
  apiKey: process.env.NEONLOOPS_API_KEY!,
  baseUrl: "https://neonloops.com",
  timeoutMs: 30_000,
  maxRetries: 3,
});

import os
from neonloops import Runner

runner = Runner(
    api_key=os.environ["NEONLOOPS_API_KEY"],
    base_url="https://neonloops.com",
    timeout=30.0,
    max_retries=3,
)

Basic Execution

Use runner.run() to execute a workflow and wait for the final result.

import { Runner, createInput } from "@neonloops/sdk";

const runner = new Runner({
  apiKey: "nl_sk_xxxxx",
});

const result = await runner.run("wf_abc123", {
  input: [createInput("user", "Hello!")],
  variables: { language: "en" },
  sessionId: "session_xyz",
});

console.log(result.output);
console.log(result.metadata.tokens);

import asyncio
from neonloops import Runner, RunInput

runner = Runner(api_key="nl_sk_xxxxx")

async def main():
    result = await runner.run(
        "wf_abc123",
        input=[RunInput(role="user", content="Hello!")],
        variables={"language": "en"},
        session_id="session_xyz",
    )
    print(result.output)
    print(result.metadata.tokens)

asyncio.run(main())

from neonloops import Runner, RunInput

runner = Runner(api_key="nl_sk_xxxxx")

result = runner.run_sync(
    "wf_abc123",
    input=[RunInput(role="user", content="Hello!")],
)
print(result.output)

Streaming

Stream events as the workflow executes using SSE. Events are emitted for each node start, completion, error, and the final result.

const stream = runner.runStream("wf_abc123", {
  input: [createInput("user", "Hello!")],
});

for await (const event of stream) {
  switch (event.type) {
    case "node:text-delta":
      // Real-time LLM tokens — build streaming UI
      process.stdout.write(event.delta);
      break;
    case "node:complete":
      console.log(`\nNode ${event.nodeId} done`);
      break;
    case "run:result":
      console.log("Output:", event.output);
      break;
  }
}

async for event in runner.run_stream(
    "wf_abc123",
    input=[RunInput(role="user", content="Hello!")],
):
    if event.type == "node:text-delta":
        # Real-time LLM tokens
        print(event.delta, end="", flush=True)
    elif event.type == "node:complete":
        print(f"\nNode {event.node_id} done")
    elif event.type == "run:result":
        print("Output:", event.output)

for event in runner.run_stream_sync(
    "wf_abc123",
    input=[RunInput(role="user", content="Hello!")],
):
    print(event.type, getattr(event, "node_id", ""))

Error Handling

Both SDKs throw typed errors for API failures and timeouts. Requests to 429 and 5xx endpoints are automatically retried with exponential backoff.

import {
  Runner,
  NeonloopsApiError,
  NeonloopsTimeoutError,
  createInput,
} from "@neonloops/sdk";

try {
  const result = await runner.run("wf_abc123", {
    input: [createInput("user", "Hello!")],
  });
} catch (err) {
  if (err instanceof NeonloopsApiError) {
    console.error(err.status, err.body);
  } else if (err instanceof NeonloopsTimeoutError) {
    console.error("Request timed out");
  }
}

from neonloops import (
    Runner,
    RunInput,
    NeonloopsApiError,
    NeonloopsTimeoutError,
)

try:
    result = runner.run_sync(
        "wf_abc123",
        input=[RunInput(role="user", content="Hello!")],
    )
except NeonloopsApiError as e:
    print(e.status, e.body)
except NeonloopsTimeoutError as e:
    print(f"Timed out after {e.timeout_s}s")

429 (rate limited) and 5xx (server error) responses are retried up to maxRetries times with exponential backoff. 4xx client errors are not retried.