API Examples

All examples assume Fabric is running at http://localhost:3001. Replace placeholder IDs with actual values from your environment.

Setup

import { FabricClient } from "@fabric-platform/sdk";
const fabric = new FabricClient({ apiKey: "fab_xxx" });

from fabric_platform import FabricClient
fabric = FabricClient(api_key="fab_xxx")

use fabric_sdk::FabricClient;
let client = FabricClient::new("http://localhost:3001", "fab_xxx")?;

export FABRIC_API_KEY="fab_xxx"
export FABRIC_URL="http://localhost:3001"
# All curl examples below use these variables

System

const health = await fabric.healthCheck();
const providers = await fabric.listProviders();

health = fabric.health_check()
providers = fabric.list_providers()

let health = client.health_check().await?;
let providers = client.list_providers().await?;

# Health check
curl $FABRIC_URL/healthz

# Readiness check
curl $FABRIC_URL/readyz

# OpenAPI spec
curl $FABRIC_URL/openapi.json

Identity

// Get current principal
const me = await fabric.getMe();

// List my organizations
const orgs = await fabric.getMyOrganizations();

// List my teams
const teams = await fabric.getMyTeams();

// Get my effective permissions
const perms = await fabric.getMyPermissions();

# Get current principal
me = fabric.get_me()

# List my organizations
orgs = fabric.get_my_organizations()

# List my teams
teams = fabric.get_my_teams()

# Get my effective permissions
perms = fabric.get_my_permissions()

// Get current principal
let me = client.get_me().await?;

// List my organizations
let orgs = client.get_my_organizations().await?;

// List my teams
let teams = client.get_my_teams().await?;

// Get my effective permissions
let perms = client.get_my_permissions().await?;

# Get current principal
curl -H "Authorization: Bearer $FABRIC_API_KEY" $FABRIC_URL/v1/me

# List my organizations
curl -H "Authorization: Bearer $FABRIC_API_KEY" $FABRIC_URL/v1/me/organizations

# List my teams
curl -H "Authorization: Bearer $FABRIC_API_KEY" $FABRIC_URL/v1/me/teams

# Get my effective permissions
curl -H "Authorization: Bearer $FABRIC_API_KEY" $FABRIC_URL/v1/me/permissions

Tenancy

// Create an organization
const org = await fabric.createOrganization({
  slug: "acme", name: "Acme Corp",
});

// Get organization details
const orgDetails = await fabric.getOrganization("<org-id>");

// List organization teams
const teams = await fabric.listTeams("<org-id>");

// List organization members
const members = await fabric.listMembers("<org-id>");

// Create a team
const team = await fabric.createTeam({
  organizationId: "<org-id>",
  slug: "engineering",
  name: "Engineering",
});

// Create an invitation
const invite = await fabric.createInvitation({
  organizationId: "<org-id>",
  email: "user@example.com",
  role: "member",
});

# Create an organization
org = fabric.create_organization(slug="acme", name="Acme Corp")

# Get organization details
org_details = fabric.get_organization("<org-id>")

# List organization teams
teams = fabric.list_teams("<org-id>")

# List organization members
members = fabric.list_members("<org-id>")

# Create a team
team = fabric.create_team(
    organization_id="<org-id>",
    slug="engineering",
    name="Engineering",
)

# Create an invitation
invite = fabric.create_invitation(
    organization_id="<org-id>",
    email="user@example.com",
    role="member",
)

// Create an organization
let org = client.create_organization("acme", "Acme Corp").await?;

// Get organization details
let org_details = client.get_organization("<org-id>").await?;

// List organization teams
let teams = client.list_teams("<org-id>").await?;

// List organization members
let members = client.list_members("<org-id>").await?;

// Create a team
let team = client.create_team("<org-id>", "engineering", "Engineering").await?;

// Create an invitation
let invite = client.create_invitation("<org-id>", "user@example.com", "member").await?;

# Create an organization
curl -X POST $FABRIC_URL/v1/organizations \
  -H 'content-type: application/json' \
  -d '{"slug":"acme","name":"Acme Corp"}'

# Get organization details
curl $FABRIC_URL/v1/organizations/<org-id>

# List organization teams
curl $FABRIC_URL/v1/organizations/<org-id>/teams

# List organization members
curl $FABRIC_URL/v1/organizations/<org-id>/members

# Create a team
curl -X POST $FABRIC_URL/v1/teams \
  -H 'content-type: application/json' \
  -d '{"organization_id":"<org-id>","slug":"engineering","name":"Engineering"}'

# Create an invitation
curl -X POST $FABRIC_URL/v1/invitations \
  -H 'content-type: application/json' \
  -d '{"organization_id":"<org-id>","email":"user@example.com","role":"member"}'

Authorization

// Single permission check
const allowed = await fabric.checkPermission({
  action: "organization.invite",
});

// Batch permission check
const results = await fabric.checkPermissions([
  { action: "organization.read" },
  { action: "team.create" },
]);

# Single permission check
allowed = fabric.check_permission(action="organization.invite")

# Batch permission check
results = fabric.check_permissions([
    {"action": "organization.read"},
    {"action": "team.create"},
])

// Single permission check
let allowed = client.check_permission_action("organization.invite").await?;

// Batch permission check
let results = client.check_permissions(vec![
    ("organization.read", None),
    ("team.create", None),
]).await?;

# Single permission check
curl -X POST $FABRIC_URL/v1/authz/check \
  -H 'content-type: application/json' \
  -d '{"action":"organization.invite"}'

# Batch permission check
curl -X POST $FABRIC_URL/v1/authz/check-batch \
  -H 'content-type: application/json' \
  -d '{"checks":[{"action":"organization.read"},{"action":"team.create"}]}'

Jobs

// Submit a job
const job = await fabric.createJob({
  modality: "image",
  tier: "premium",
  input: { prompt: "a cat in space" },
  params: { size: "1024x1024" },
  organizationId: "<org-id>",
});

// Submit with idempotency key
const job2 = await fabric.createJob({
  modality: "text",
  input: { prompt: "Hello world" },
  organizationId: "<org-id>",
  idempotencyKey: "unique-request-id-123",
});

// Get job status
const status = await fabric.getJob("<job-id>");

// List jobs
const jobs = await fabric.listJobs();

// Get job usage
const usage = await fabric.getJobUsage("<job-id>");

# Submit a job
job = fabric.create_job(
    modality="image",
    tier="premium",
    input={"prompt": "a cat in space"},
    params={"size": "1024x1024"},
    organization_id="<org-id>",
)

# Submit with idempotency key
job2 = fabric.create_job(
    modality="text",
    input={"prompt": "Hello world"},
    organization_id="<org-id>",
    idempotency_key="unique-request-id-123",
)

# Get job status
status = fabric.get_job("<job-id>")

# List jobs
jobs = fabric.list_jobs()

# Get job usage
usage = fabric.get_job_usage("<job-id>")

// Submit a job
let job = client.create_job(serde_json::json!({
    "modality": "image",
    "tier": "premium",
    "input": {"prompt": "a cat in space"},
    "params": {"size": "1024x1024"},
    "organization_id": "<org-id>"
})).await?;

// Get job status
let status = client.get_job("<job-id>").await?;

// List jobs
let jobs = client.list_jobs().await?;

// Get job usage
let usage = client.get_job_usage("<job-id>").await?;

# Submit a job
curl -X POST $FABRIC_URL/v1/jobs \
  -H 'content-type: application/json' \
  -d '{
    "modality": "image",
    "tier": "premium",
    "input": {"prompt": "a cat in space"},
    "params": {"size": "1024x1024"},
    "organization_id": "<org-id>"
  }'

# Submit with idempotency key
curl -X POST $FABRIC_URL/v1/jobs \
  -H 'content-type: application/json' \
  -d '{
    "modality": "text",
    "input": {"prompt": "Hello world"},
    "organization_id": "<org-id>",
    "idempotency_key": "unique-request-id-123"
  }'

# Get job status
curl $FABRIC_URL/v1/jobs/<job-id>

# List jobs
curl $FABRIC_URL/v1/jobs

# Get job usage
curl $FABRIC_URL/v1/jobs/<job-id>/usage

Workflows

import { WorkflowBuilder } from "@fabric-platform/sdk";

// Create a workflow definition
const workflow = new WorkflowBuilder("transcribe-and-summarize")
  .node("transcribe", "ai_invoke", (n) =>
    n.config({ operation: "audio.transcribe", modality: "audio" })
  )
  .node("summarize", "ai_invoke", (n) =>
    n.dependsOn("transcribe")
     .config({ operation: "ai.generate", modality: "text" })
  )
  .build();

const defId = await fabric.registerDefinition(workflow);

// Create and run
const result = await fabric.runDefinition(workflow, {
  context: { audio: { url: "https://example.com/audio.wav" } },
});

// Or step by step:
const runId = await fabric.runWorkflow(defId, {
  audio: { url: "https://example.com/audio.wav" },
});

// Start execution
await fabric.startRun(runId);

// Cancel if needed
await fabric.cancelRun(runId);

# Create a workflow definition
wf_id = fabric.upsert_workflow("transcribe-and-summarize", nodes=[
    {
        "key": "transcribe",
        "operation": "audio.transcribe",
        "runtime": "provider",
        "config": {"modality": "audio"},
    },
    {
        "key": "summarize",
        "operation": "ai.generate",
        "runtime": "provider",
        "depends_on": ["transcribe"],
        "config": {"modality": "text"},
    },
])

# Create a run
run_id = fabric.run_workflow(wf_id, context={
    "audio": {"url": "https://example.com/audio.wav"},
})

# Wait for completion
result = fabric.wait_for_run(run_id)

# Cancel if needed
fabric.cancel_run(run_id)

// Create a workflow definition
let wf_id = client.upsert_workflow("transcribe-and-summarize", serde_json::json!({
    "nodes": [
        {"key": "transcribe", "operation": "audio.transcribe", "runtime": "provider"},
        {"key": "summarize", "operation": "ai.generate", "runtime": "provider",
         "depends_on": ["transcribe"]}
    ]
})).await?;

// Create a run
let run_id = client.run_workflow(wf_id, serde_json::json!({
    "audio": {"url": "https://example.com/audio.wav"}
})).await?;

// Wait for completion
let result = client.wait_for_run(run_id).await?;

# Create a workflow definition
curl -X POST $FABRIC_URL/v1/workflow-definitions \
  -H 'content-type: application/json' \
  -d '{
    "name": "transcribe-and-summarize",
    "organization_id": "<org-id>",
    "nodes": [
      {"key":"transcribe","operation":"audio.transcribe","runtime":"provider","config":{"modality":"audio"}},
      {"key":"summarize","operation":"ai.generate","runtime":"provider","depends_on":["transcribe"],"config":{"modality":"text"}}
    ]
  }'

# Create a workflow run
curl -X POST $FABRIC_URL/v1/workflow-runs \
  -H 'content-type: application/json' \
  -d '{"workflow_definition_id":"<definition-id>","context":{"audio":{"url":"https://example.com/audio.wav"}}}'

# Start a workflow run
curl -X POST $FABRIC_URL/v1/workflow-runs/<run-id>/start

# Cancel a workflow run
curl -X POST $FABRIC_URL/v1/workflow-runs/<run-id>/cancel

Providers

// List available providers
const providers = await fabric.listProviders();

// Execute a provider request
const result = await fabric.executeProvider({
  modality: "text",
  model: "qwen3:latest",
  input: { prompt: "Explain quantum computing in one sentence" },
  params: { temperature: 0.7 },
});

// Estimate cost
const estimate = await fabric.estimateCost({
  modality: "text",
  model: "gpt-4",
  input: { prompt: "Hello world" },
});

# List available providers
providers = fabric.list_providers()

# Execute a provider request
result = fabric.execute_provider(
    modality="text",
    model="qwen3:latest",
    input={"prompt": "Explain quantum computing in one sentence"},
    params={"temperature": 0.7},
)

# Estimate cost
estimate = fabric.estimate_cost(
    modality="text",
    model="gpt-4",
    input={"prompt": "Hello world"},
)

// List available providers
let providers = client.list_providers().await?;

// Execute a provider request
let result = client.execute_provider(serde_json::json!({
    "modality": "text",
    "model": "qwen3:latest",
    "input": {"prompt": "Explain quantum computing in one sentence"},
    "params": {"temperature": 0.7}
})).await?;

// Estimate cost
let estimate = client.estimate_cost(serde_json::json!({
    "modality": "text",
    "model": "gpt-4",
    "input": {"prompt": "Hello world"}
})).await?;

# List available providers
curl $FABRIC_URL/v1/providers

# Execute a provider request
curl -X POST $FABRIC_URL/v1/providers/execute \
  -H 'content-type: application/json' \
  -d '{
    "modality": "text",
    "model": "qwen3:latest",
    "input": {"prompt": "Explain quantum computing in one sentence"},
    "params": {"temperature": 0.7}
  }'

# Stream a provider response (SSE)
curl -N -X POST $FABRIC_URL/v1/providers/execute/stream \
  -H 'content-type: application/json' \
  -d '{
    "modality": "text",
    "model": "qwen3:latest",
    "input": {"prompt": "Write a haiku about Rust"},
    "params": {"stream": true}
  }'

# Estimate cost
curl -X POST $FABRIC_URL/v1/providers/estimate \
  -H 'content-type: application/json' \
  -d '{"modality":"text","model":"gpt-4","input":{"prompt":"Hello world"}}'

API Keys

// Create an API key
const key = await fabric.createApiKey({
  name: "my-service-key",
  organizationId: "<org-id>",
  scopes: ["jobs:write", "providers:execute"],
});
console.log("Store this key:", key.raw_key);

// List API keys
const keys = await fabric.listApiKeys();

// Revoke an API key
await fabric.deleteApiKey("<key-id>");

# Create an API key
key = fabric.create_api_key(
    name="my-service-key",
    organization_id="<org-id>",
    scopes=["jobs:write", "providers:execute"],
)
print("Store this key:", key["raw_key"])

# List API keys
keys = fabric.list_api_keys()

# Revoke an API key
fabric.delete_api_key("<key-id>")

// Create an API key
let key = client.create_api_key(serde_json::json!({
    "name": "my-service-key",
    "organization_id": "<org-id>",
    "scopes": ["jobs:write", "providers:execute"]
})).await?;
println!("Store this key: {}", key.raw_key);

// List API keys
let keys = client.list_api_keys().await?;

// Revoke an API key
client.delete_api_key("<key-id>").await?;

# Create an API key (raw key shown only once!)
curl -X POST $FABRIC_URL/v1/api-keys \
  -H 'content-type: application/json' \
  -d '{"name":"my-service-key","organization_id":"<org-id>","scopes":["jobs:write","providers:execute"]}'

# List API keys
curl $FABRIC_URL/v1/api-keys

# Revoke an API key
curl -X DELETE $FABRIC_URL/v1/api-keys/<key-id>

Events

// Stream all events
await fabric.streamEvents((event) => {
  console.log(event.kind, event.payload);
});

// Stream job events
await fabric.streamEvents("<job-id>", (event) => {
  console.log(event.kind);
});

// Wait for a workflow run
const result = await fabric.waitForRun("<run-id>", {
  onEvent: (e) => console.log(e.kind),
});

# Stream all events
for event in fabric.stream_events():
    print(event["kind"], event.get("payload"))

# Stream job events
for event in fabric.stream_job_events("<job-id>"):
    print(event["kind"])

# Stream workflow run events
for event in fabric.stream_run_events("<run-id>"):
    print(event["kind"])

// Stream all events
let mut stream = client.stream_events().await?;
while let Some(event) = stream.next().await {
    println!("{} {:?}", event.kind, event.payload);
}

# Stream all events (SSE)
curl -N $FABRIC_URL/v1/events/stream

# Stream job events
curl -N $FABRIC_URL/v1/jobs/<job-id>/events

# Stream workflow run events
curl -N $FABRIC_URL/v1/workflow-runs/<run-id>/events

# WebSocket events
wscat -c ws://localhost:3001/v1/events/ws

Usage & Audit

// Organization usage summary
const usage = await fabric.getOrgUsage("<org-id>");

// Detailed usage records
const records = await fabric.getOrgUsageRecords("<org-id>");

// Audit logs
const logs = await fabric.getOrgAuditLogs("<org-id>");

# Organization usage summary
usage = fabric.get_org_usage("<org-id>")

# Detailed usage records
records = fabric.get_org_usage_records("<org-id>")

# Audit logs
logs = fabric.get_org_audit_logs("<org-id>")

// Organization usage summary
let usage = client.get_org_usage("<org-id>").await?;

// Detailed usage records
let records = client.get_org_usage_records("<org-id>").await?;

// Audit logs
let logs = client.get_org_audit_logs("<org-id>").await?;

# Organization usage summary
curl $FABRIC_URL/v1/organizations/<org-id>/usage

# Detailed usage records
curl $FABRIC_URL/v1/organizations/<org-id>/usage/records

# Organization audit logs
curl $FABRIC_URL/v1/organizations/<org-id>/audit-logs

# Global audit logs
curl $FABRIC_URL/v1/audit-logs