SDK reference

npm install @strixhood/sdk
pnpm add @strixhood/sdk
bun add @strixhood/sdk
deno add npm:@strixhood/sdk

pip install strixhood
# streaming + webhook helpers
pip install "strixhood[stream,webhooks]"

cargo add strix-hood --features rustls,stream
# Cargo.toml
# strix-hood = { version = "1.4", features = ["rustls", "stream"] }

import { Strix } from "@strixhood/sdk";

const strix = new Strix({ apiKey: process.env.STRIX_API_KEY! });
console.log(await strix.ping());
// { ok: true, apiVersion: "2026-07-01", livemode: false, latencyMs: 41 }

import os
from strixhood import Strix

strix = Strix(api_key=os.environ["STRIX_API_KEY"])
print(strix.ping())
# {'ok': True, 'api_version': '2026-07-01', 'livemode': False, 'latency_ms': 41}

use strix_hood::Strix;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let strix = Strix::from_env()?;
    println!("{:?}", strix.ping().await?);
    Ok(())
}

import { Strix } from "@strixhood/sdk";

export const strix = new Strix({
  apiKey: process.env.STRIX_API_KEY!,      // required
  apiVersion: "2026-07-01",                // pin explicitly in production
  baseUrl: "https://api.strixhood.xyz/v1", // override for a private deployment
  timeoutMs: 20_000,
  maxRetries: 4,
  telemetry: false,
});

import os
from strixhood import Strix, AsyncStrix

strix = Strix(
    api_key=os.environ["STRIX_API_KEY"],
    api_version="2026-07-01",
    base_url="https://api.strixhood.xyz/v1",
    timeout=20.0,
    max_retries=4,
    telemetry=False,
)

# identical surface, awaitable
astrix = AsyncStrix(api_key=os.environ["STRIX_API_KEY"])

use std::time::Duration;
use strix_hood::{Strix, StrixConfig};

pub fn client() -> anyhow::Result<Strix> {
    Strix::new(StrixConfig {
        api_key: std::env::var("STRIX_API_KEY")?,
        api_version: "2026-07-01".into(),
        base_url: "https://api.strixhood.xyz/v1".parse()?,
        timeout: Duration::from_secs(20),
        max_retries: 4,
        telemetry: false,
    })
}

const agent = await strix.agents.create({
  name: "dca-eth",
  kind: "trader",
  policyId: policy.id,
  chains: ["eip155:8453"],
  sessionKey: { ttlSeconds: 86_400, rotate: true },
}, { idempotencyKey: "create-dca-eth-01" });

agent.status;                 // "active"
agent.smartAccount;           // "0x1F3c7A9b04E2d586Cf01B7e34a9D2c6058Ba9aE2"
agent.passport.tokenId;       // "4182"
agent.policy.hash;            // "0x7d41a9c0…"
agent.sessionKeys[0].expiresAt; // Date

agent = strix.agents.create(
    name="dca-eth",
    kind="trader",
    policy_id=policy.id,
    chains=["eip155:8453"],
    session_key={"ttl_seconds": 86_400, "rotate": True},
    idempotency_key="create-dca-eth-01",
)

agent.status                     # "active"
agent.smart_account              # "0x1F3c…9aE2"
agent.passport.token_id          # "4182"
agent.session_keys[0].expires_at # datetime, tz-aware

use strix_hood::{CreateAgent, SessionKey};

let agent = strix
    .agents()
    .create(CreateAgent {
        name: "dca-eth".into(),
        kind: "trader".into(),
        policy_id: policy.id.clone(),
        chains: vec!["eip155:8453".into()],
        session_key: Some(SessionKey { ttl_seconds: 86_400, rotate: true }),
        ..Default::default()
    })
    .idempotency_key("create-dca-eth-01")
    .await?;

println!("{} {}", agent.status, agent.smart_account);

// one page
const page = await strix.agents.list({ status: "active", limit: 25 });
page.data.length; page.hasMore; page.nextCursor;

// every page, lazily
for await (const agent of strix.agents.listAll({ status: "active" })) {
  console.log(agent.id, agent.reputation.score);
}

page = strix.agents.list(status="active", limit=25)
len(page.data), page.has_more, page.next_cursor

# every page, lazily
for agent in strix.agents.list_all(status="active"):
    print(agent.id, agent.reputation.score)

use futures::TryStreamExt;

let page = strix.agents().list().status("active").limit(25).await?;

let mut stream = strix.agents().list().status("active").paginate();
while let Some(agent) = stream.try_next().await? {
    println!("{} {:?}", agent.id, agent.reputation.score);
}

const intent = await strix.intents.create({
  agentId: agent.id,
  action: "swap",
  chain: "eip155:8453",
  params: { sellToken: "USDC", buyToken: "WETH", sellAmount: "150.00" },
  constraints: { maxSlippageBps: 40, routePreference: "best_price" },
}, { idempotencyKey: "dca-2026-08-16-0900" });

intent.status;              // "simulating"
intent.estimated.buyAmount; // "0.04129"
intent.estimated.feeUsd;    // 0.375

from decimal import Decimal

intent = strix.intents.create(
    agent_id=agent.id,
    action="swap",
    chain="eip155:8453",
    params={"sell_token": "USDC", "buy_token": "WETH", "sell_amount": Decimal("150.00")},
    constraints={"max_slippage_bps": 40, "route_preference": "best_price"},
    idempotency_key="dca-2026-08-16-0900",
)

intent.status                 # "simulating"
intent.estimated.buy_amount   # Decimal("0.04129")

use rust_decimal_macros::dec;
use strix_hood::{CreateIntent, Constraints, SwapParams};

let intent = strix
    .intents()
    .create(CreateIntent {
        agent_id: agent.id.clone(),
        action: "swap".into(),
        chain: "eip155:8453".into(),
        params: SwapParams {
            sell_token: "USDC".into(),
            buy_token: "WETH".into(),
            sell_amount: Some(dec!(150.00)),
            ..Default::default()
        }
        .into(),
        constraints: Some(Constraints {
            max_slippage_bps: Some(40),
            route_preference: Some("best_price".into()),
            ..Default::default()
        }),
        ..Default::default()
    })
    .idempotency_key("dca-2026-08-16-0900")
    .await?;

import { IntentRejectedError } from "@strixhood/sdk";

try {
  const settled = await strix.intents.waitFor(intent.id, { timeoutMs: 90_000 });
  console.log(settled.settled.buyAmount, settled.settled.feeUsdSettled);
} catch (err) {
  if (err instanceof IntentRejectedError) {
    console.error(err.rule, err.message); // "limits.daily_usd", "…exceeds…"
  } else {
    throw err;
  }
}

// or: resolve on any terminal status, never throw
const outcome = await strix.intents.waitFor(intent.id, { throwOnFailure: false });

from strixhood.errors import IntentRejected

try:
    settled = strix.intents.wait_for(intent.id, timeout=90.0)
    print(settled.settled.buy_amount, settled.settled.fee_usd_settled)
except IntentRejected as err:
    print(err.rule, err.message)

outcome = strix.intents.wait_for(intent.id, throw_on_failure=False)

use std::time::Duration;
use strix_hood::StrixError;

match strix.intents().wait_for(&intent.id, Duration::from_secs(90)).await {
    Ok(settled) => println!("{}", settled.settled.buy_amount),
    Err(StrixError::IntentRejected { rule, message, .. }) => {
        eprintln!("refused by {rule}: {message}");
    }
    Err(e) => return Err(e.into()),
}

const policy = await strix.policies.create({
  name: "dca-conservative",
  limits: { perTxUsd: 250, dailyUsd: 1_000, monthlyUsd: 20_000, maxOpenIntents: 4 },
  allow: {
    chains: ["eip155:8453"],
    actions: ["swap"],
    tokens: ["USDC", "WETH"],
    venues: ["uniswap_v4", "aerodrome"],
  },
  deny: { categories: ["leverage", "gambling", "unverified_contract"] },
  simulation: { requireSuccess: true, maxPriceImpactBps: 120, minLiquidityUsd: 250_000 },
  hitl: { thresholdUsd: 200, channels: ["webhook"], timeoutSec: 180, onTimeout: "reject" },
  expiresAt: new Date("2027-01-01T00:00:00Z"),
});

from datetime import datetime, timezone

policy = strix.policies.create(
    name="dca-conservative",
    limits={"per_tx_usd": 250, "daily_usd": 1_000, "monthly_usd": 20_000, "max_open_intents": 4},
    allow={
        "chains": ["eip155:8453"],
        "actions": ["swap"],
        "tokens": ["USDC", "WETH"],
        "venues": ["uniswap_v4", "aerodrome"],
    },
    deny={"categories": ["leverage", "gambling", "unverified_contract"]},
    simulation={"require_success": True, "max_price_impact_bps": 120,
                "min_liquidity_usd": 250_000},
    hitl={"threshold_usd": 200, "channels": ["webhook"],
          "timeout_sec": 180, "on_timeout": "reject"},
    expires_at=datetime(2027, 1, 1, tzinfo=timezone.utc),
)

use strix_hood::policy::{Allow, Deny, Hitl, Limits, NewPolicy, Simulation};

let policy = strix
    .policies()
    .create(NewPolicy {
        name: "dca-conservative".into(),
        limits: Limits { per_tx_usd: dec!(250), daily_usd: Some(dec!(1000)),
                         monthly_usd: Some(dec!(20000)), max_open_intents: Some(4),
                         ..Default::default() },
        allow: Allow { chains: vec!["eip155:8453".into()],
                       actions: vec!["swap".into()],
                       tokens: vec!["USDC".into(), "WETH".into()],
                       ..Default::default() },
        deny: Some(Deny { categories: vec!["leverage".into(), "gambling".into()],
                          ..Default::default() }),
        simulation: Some(Simulation { require_success: true,
                                      max_price_impact_bps: Some(120),
                                      min_liquidity_usd: Some(dec!(250000)) }),
        hitl: Some(Hitl { threshold_usd: Some(dec!(200)), timeout_sec: 180,
                          on_timeout: "reject".into(), ..Default::default() }),
        ..Default::default()
    })
    .await?;

const quote = await strix.quotes.create({
  action: "swap",
  chain: "eip155:8453",
  params: { sellToken: "USDC", buyToken: "WETH", sellAmount: "150.00" },
  agentId: agent.id,          // also returns policyOk
});

quote.buy.minimum;            // "0.041128" — the guaranteed floor
quote.priceImpactBps;         // 6
quote.policyOk;               // true
quote.expiresAt;              // Date, ~12 s out
quote.routes.map((r) => [r.solver, r.venue, r.out]);

const venues = await strix.routes.list({ chain: "eip155:42161", kind: "rwa_equity" });
venues.data[0].session;       // { opensAt, closesAt, continuousSecondary }

quote = strix.quotes.create(
    action="swap",
    chain="eip155:8453",
    params={"sell_token": "USDC", "buy_token": "WETH", "sell_amount": "150.00"},
    agent_id=agent.id,
)

quote.buy.minimum        # Decimal("0.041128")
quote.price_impact_bps   # 6
quote.policy_ok          # True

venues = strix.routes.list(chain="eip155:42161", kind="rwa_equity")
venues.data[0].session

let quote = strix
    .quotes()
    .create(NewQuote {
        action: "swap".into(),
        chain: "eip155:8453".into(),
        params: SwapParams { sell_token: "USDC".into(), buy_token: "WETH".into(),
                             sell_amount: Some(dec!(150.00)), ..Default::default() }.into(),
        agent_id: Some(agent.id.clone()),
        ..Default::default()
    })
    .await?;

println!("floor {} impact {}bps", quote.buy.minimum, quote.price_impact_bps);

const pf = await strix.portfolio.get({ agentId: agent.id, minValueUsd: 1 });

pf.totalValueUsd;    // 48213.77
pf.change24hPct;     // 1.84
pf.tokens.find((t) => t.symbol === "WETH")?.allocationPct; // 71

const history = await strix.portfolio.history({
  agentId: agent.id, interval: "1h", range: "24h",
});

for await (const txn of strix.portfolio.transactionsAll({ agentId: agent.id })) {
  if (txn.intentId === null) console.log("external movement", txn.kind, txn.valueUsd);
}

pf = strix.portfolio.get(agent_id=agent.id, min_value_usd=1)

pf.total_value_usd    # Decimal("48213.77")
pf.change_24h_pct     # 1.84

history = strix.portfolio.history(agent_id=agent.id, interval="1h", range="24h")

for txn in strix.portfolio.transactions_all(agent_id=agent.id):
    if txn.intent_id is None:
        print("external movement", txn.kind, txn.value_usd)

let pf = strix.portfolio().get(&agent.id).min_value_usd(dec!(1)).await?;
println!("{} ({:+.2}%)", pf.total_value_usd, pf.change_24h_pct);

let mut txns = strix.portfolio().transactions(&agent.id).paginate();
while let Some(txn) = txns.try_next().await? {
    if txn.intent_id.is_none() {
        println!("external movement {} {}", txn.kind, txn.value_usd);
    }
}

const stream = strix.stream.executions({
  agentIds: [agent.id],
  chains: ["eip155:8453"],
});

for await (const evt of stream) {
  switch (evt.status) {
    case "submitted":
      console.log("broadcast", evt.fills[0]?.txHash);
      break;
    case "settled":
      console.log("filled", evt.fills[0].buyAmount, "att", evt.attestation.uid);
      break;
    case "failed":
      console.error("reverted", evt.failure?.reason);
      break;
  }
}

// stop cleanly — closes the socket and ends the iterator
await stream.close();

import asyncio
from strixhood import AsyncStrix

async def main() -> None:
    strix = AsyncStrix(api_key=os.environ["STRIX_API_KEY"])
    async with strix.stream.executions(agent_ids=[agent.id]) as stream:
        async for evt in stream:
            if evt.status == "settled":
                print("filled", evt.fills[0].buy_amount)
            elif evt.status == "failed":
                print("reverted", evt.failure.reason)

asyncio.run(main())

use futures::StreamExt;
use strix_hood::stream::ExecutionFilter;

let mut stream = strix
    .stream()
    .executions(ExecutionFilter { agent_ids: vec![agent.id.clone()], ..Default::default() })
    .await?;

while let Some(evt) = stream.next().await {
    let evt = evt?;
    match evt.status.as_str() {
        "settled" => println!("filled {}", evt.fills[0].buy_amount),
        "failed"  => eprintln!("reverted {:?}", evt.failure),
        _ => {}
    }
}

import express from "express";
import { Strix, WebhookSignatureError } from "@strixhood/sdk";

const app = express();
const strix = new Strix({ apiKey: process.env.STRIX_API_KEY! });

// raw body, not express.json()
app.post("/hooks/strix", express.raw({ type: "application/json" }), (req, res) => {
  let event;
  try {
    event = strix.webhooks.verify({
      payload: req.body,                              // Buffer
      signature: req.header("Strix-Signature")!,
      secret: process.env.STRIX_WEBHOOK_SECRET!,
      toleranceSeconds: 300,
    });
  } catch (err) {
    if (err instanceof WebhookSignatureError) return res.sendStatus(400);
    throw err;
  }

  res.sendStatus(202);          // acknowledge first
  void queue.push(event);       // then do the work
});

from fastapi import FastAPI, Request, Response, BackgroundTasks
from strixhood import Strix
from strixhood.errors import WebhookSignatureError

app = FastAPI()
strix = Strix(api_key=os.environ["STRIX_API_KEY"])

@app.post("/hooks/strix")
async def hook(request: Request, tasks: BackgroundTasks) -> Response:
    raw = await request.body()
    try:
        event = strix.webhooks.verify(
            payload=raw,
            signature=request.headers["strix-signature"],
            secret=os.environ["STRIX_WEBHOOK_SECRET"],
            tolerance_seconds=300,
        )
    except WebhookSignatureError:
        return Response(status_code=400)

    tasks.add_task(handle, event)
    return Response(status_code=202)

use axum::{body::Bytes, http::{HeaderMap, StatusCode}};
use strix_hood::webhooks;

async fn hook(headers: HeaderMap, body: Bytes) -> StatusCode {
    let sig = match headers.get("strix-signature").and_then(|v| v.to_str().ok()) {
        Some(s) => s,
        None => return StatusCode::BAD_REQUEST,
    };

    let event = match webhooks::verify(&body, sig, secret(), 300) {
        Ok(e) => e,
        Err(_) => return StatusCode::BAD_REQUEST,
    };

    tokio::spawn(handle(event));
    StatusCode::ACCEPTED
}

import { PolicyError, RateLimitError, StrixError } from "@strixhood/sdk";

try {
  await strix.intents.create(body);
} catch (err) {
  if (err instanceof PolicyError) {
    // err.rule === "limits.daily_usd"; not retryable, the budget is spent
    metrics.inc("policy_refusal", { rule: err.rule });
    await pauseUntilWindowResets(err.rule);
  } else if (err instanceof RateLimitError) {
    await sleep(err.retryAfterMs);
  } else if (err instanceof StrixError) {
    log.error({ requestId: err.requestId, code: err.code }, err.message);
    throw err;
  } else {
    throw err;
  }
}

from strixhood.errors import PolicyError, RateLimitError, StrixError

try:
    strix.intents.create(**body)
except PolicyError as err:
    metrics.inc("policy_refusal", rule=err.rule)
    pause_until_window_resets(err.rule)
except RateLimitError as err:
    time.sleep(err.retry_after)
except StrixError as err:
    log.error("%s %s: %s", err.request_id, err.code, err.message)
    raise

use strix_hood::StrixError;

match strix.intents().create(body).await {
    Ok(intent) => Ok(intent),
    Err(StrixError::Policy { rule, .. }) => {
        metrics::inc("policy_refusal", &rule);
        pause_until_window_resets(&rule).await;
        Err(anyhow!("refused by {rule}"))
    }
    Err(StrixError::RateLimit { retry_after, .. }) => {
        tokio::time::sleep(retry_after).await;
        Err(anyhow!("rate limited"))
    }
    Err(e) => Err(e.into()),
}