SDKs

from splox import SploxClient

client = SploxClient(api_key="YOUR_API_KEY")

# List workflows
workflows = client.workflows.list()
for wf in workflows.workflows:
    print(wf.id, wf.latest_version.name)

# Create a chat and run a workflow
chat = client.chats.create(name="My Session", resource_id=wf.id)
version = client.workflows.get_latest_version(wf.id)
entry_nodes = client.workflows.get_entry_nodes(version.id)

result = client.workflows.run(
    workflow_version_id=version.id,
    chat_id=chat.id,
    entry_node_ids=[entry_nodes.nodes[0].id],
    query="Hello, world!",
)

# Stream real-time updates
for event in client.workflows.listen(result.workflow_request_id):
    if event.node_execution:
        print(f"[{event.node_execution.status}] {event.node_execution.node_id}")

# Check your balance
balance = client.billing.get_balance()
print(f"Balance: ${balance.balance_usd:.2f}")

import Splox from "splox";

const client = new Splox("YOUR_API_KEY");

// List workflows
const { workflows } = await client.workflows.list();
const wf = workflows[0];

// Create a chat and run a workflow
const chat = await client.chats.create({
  name: "My Session",
  resource_id: wf.id,
});
const version = await client.workflows.getLatestVersion(wf.id);
const { nodes } = await client.workflows.getEntryNodes(version.id);

const { workflow_request_id } = await client.workflows.run({
  workflow_version_id: version.id,
  chat_id: chat.id,
  entry_node_ids: [nodes[0].id],
  query: "Hello, world!",
});

// Stream real-time updates
const stream = await client.workflows.listen(workflow_request_id);
for await (const event of stream) {
  if (event.node_execution) {
    console.log(`[${event.node_execution.status}] ${event.node_execution.node_id}`);
  }
}

// Check your balance
const balance = await client.billing.getBalance();
console.log(`Balance: $${balance.balance_usd.toFixed(2)}`);

package main

import (
    "context"
    "fmt"
    splox "github.com/splox-ai/go-sdk"
)

func main() {
    client := splox.NewClient("YOUR_API_KEY")
    ctx := context.Background()

    // List workflows
    list, _ := client.Workflows.List(ctx, nil)
    wf := list.Workflows[0]

    // Create a chat and run a workflow
    chat, _ := client.Chats.Create(ctx, splox.CreateChatParams{
        Name:       "My Session",
        ResourceID: wf.ID,
    })
    version, _ := client.Workflows.GetLatestVersion(ctx, wf.ID)
    entryNodes, _ := client.Workflows.GetEntryNodes(ctx, version.ID)

    result, _ := client.Workflows.Run(ctx, splox.RunParams{
        WorkflowVersionID: version.ID,
        ChatID:            chat.ID,
        EntryNodeIDs:      []string{entryNodes.Nodes[0].ID},
        Query:             "Hello, world!",
    })

    // Stream real-time updates
    iter, _ := client.Workflows.Listen(ctx, result.WorkflowRequestID)
    defer iter.Close()
    for iter.Next() {
        ev := iter.Event()
        if ev.NodeExecution != nil {
            fmt.Printf("[%s] %s\n", ev.NodeExecution.Status, ev.NodeExecution.NodeID)
        }
    }

    // Check your balance
    balance, _ := client.Billing.GetBalance(ctx)
    fmt.Printf("Balance: $%.2f\n", balance.BalanceUSD)
}

# Explicit
client = SploxClient(api_key="YOUR_API_KEY")

# From environment variable SPLOX_API_KEY
client = SploxClient()

// Explicit
const client = new Splox("YOUR_API_KEY");

// From environment variable SPLOX_API_KEY
const client = new Splox();

// Explicit
client := splox.NewClient("YOUR_API_KEY")

// From environment variable SPLOX_API_KEY
client := splox.NewClient("")

from splox import SploxClient
from splox.exceptions import (
    AuthenticationError,
    NotFoundError,
    RateLimitError,
)

try:
    client.workflows.get("nonexistent-id")
except AuthenticationError:
    print("Invalid API key")
except NotFoundError:
    print("Workflow not found")
except RateLimitError as e:
    print(f"Rate limited — retry after {e.retry_after}s")

import Splox, { AuthenticationError, NotFoundError, RateLimitError } from "splox";

try {
  await client.workflows.get("nonexistent-id");
} catch (e) {
  if (e instanceof AuthenticationError) {
    console.log("Invalid API key");
  } else if (e instanceof NotFoundError) {
    console.log("Workflow not found");
  } else if (e instanceof RateLimitError) {
    console.log(`Rate limited — retry after ${e.retryAfter}s`);
  }
}

import "errors"

_, err := client.Workflows.Get(ctx, "nonexistent-id")
if err != nil {
    var notFound *splox.NotFoundError
    var rateLimit *splox.RateLimitError
    switch {
    case errors.As(err, &notFound):
        fmt.Println("Workflow not found")
    case errors.As(err, &rateLimit):
        fmt.Printf("Rate limited — retry after %v\n", rateLimit.RetryAfter)
    }
}