Quick Start - Threadify Documentation

Before you start

Run your Engine, sign in, and create an API key under Developer → API Keys. Use your Engine’s address in the examples below.

1. Install the SDK

JavaScript
Go
Python

npm install @threadify/sdk

go get github.com/ThreadifyDev/go-sdk

pip install threadify-sdk

2. Connect to Threadify

JavaScript
Go
Python

import { Threadify } from '@threadify/sdk';

// Connect with your API key and service name
const connection = await Threadify.connect('your-api-key', 'my-service', {
  engineUrl: 'https://threadify.example.com' // Your Settings → Engine address
});

ctx := context.Background()
conn, err := threadify.Connect(ctx, "your-api-key", 
    threadify.WithServiceName("my-service"),
    threadify.WithEngineURL("https://threadify.example.com"),
)
if err != nil {
    log.Fatal(err)
}
defer conn.Close()

from threadify import Threadify

# Connect with your API key and service name
connection = await Threadify.connect(
    "your-api-key",
    service_name="my-service",
    engine_url="https://threadify.example.com",
)

3. Create or Resume Your Thread

JavaScript
Go
Python

// Use an application order ID as the key, with a human-readable label
const thread = await connection.thread('order:ORD-123', { label: 'Order ORD-123' });

// Use an application order ID as the key, with a human-readable label
thread, err := conn.Thread(ctx, "order:ORD-123", threadify.ThreadOptions{Label: "Order ORD-123"})
if err != nil {
    log.Fatal(err)
}

# Use an application order ID as the key, with a human-readable label
thread = await connection.thread("order:ORD-123", {"label": "Order ORD-123"})

Reuse this key in later requests to recover the same active thread; the optional object is only needed to provide creation defaults. Threadify manages its internal ID. A closed thread cannot accept more steps, so choose a fresh key for each new order. See threads and steps for contracted sessions and examples in all three SDKs.

4. Add Steps to Your Process

JavaScript
Go
Python

// Create step first, then call methods on it
const step = thread.step('validate_input');
await step.addContext({ userId: 'user-123' }).success();

// Or chain directly on the step builder
await thread.step('process_data')
  .addContext({ records: 42 })
  .success();

// Create step first, then call methods on it
step := thread.Step("validate_input")
_, err = step.AddContext(map[string]any{"userId": "user-123"}).Success(ctx)
if err != nil {
    log.Fatal(err)
}

// Or chain directly on the step builder
_, err = thread.Step("process_data").
    AddContext(map[string]any{"records": 42}).
    Success(ctx)
if err != nil {
    log.Fatal(err)
}

# Create step first, then call methods on it
step = thread.step("validate_input")
await step.add_context({"userId": "user-123"}).success()

# Or chain directly on the step builder
await (
    thread.step("process_data")
    .add_context({"records": 42})
    .success()
)

5. Finish and inspect

This example created a free-form thread. Finish it explicitly:

await thread.complete('Finished');
await connection.close();

_, err = thread.Complete(ctx, "Finished")
if err != nil { log.Fatal(err) }

await thread.complete("Finished")
await connection.close()

Open Threads in your Engine dashboard. Archived views can take a short time to catch up with accepted events. Next, add a contract and an explicit wait when your code must check permission before acting. Next: create a contract, check before acting, or troubleshoot ingestion.