TypeScript & Python

Embed governed app access
from your backend

Use the SDKs to create workspaces, connect users, mount approved apps, create MCP servers, issue scoped tokens, and give agents access to 1,000+ app integrations and 12,000+ agent tools.

1,000+ app integrations12,000+ agent toolsTypeScript + Python

TypeScript Docs Python Docs

Install SDKs

Start from the package manager your stack already uses.

Generated types

npm install @weavz-io/sdk

pip install weavz-io-sdk

Typed action inputs

Connect links

MCP server tokens

Get started in seconds

Jump from install to API reference, language guides, and LLM-ready docs without hunting through the site.

TypeScript

@weavz-io/sdk

Compile-time action names and generated input types for all integrations. Works in Node.js, Deno, Bun, and edge runtimes.

import { WeavzClient } from "@weavz-io/sdk";

const client = new WeavzClient({
  apiKey: "wvz_your_api_key",
});

const workspaceId = "550e8400-e29b-41d4-a716-446655440000";

// Execute an action
const result = await client.actions.execute("slack", "send_channel_message", {
  workspaceId,
  integrationAlias: "office_slack",
  input: {
    channel: "#general",
    text: "Hello from the TypeScript SDK!",
  },
});

// Manage connections
const connections = await client.connections.list({
  integrationName: "slack",
});

// Create an MCP server
const server = await client.mcpServers.create({
  name: "My Server",
  workspaceId,
  mode: "TOOLS",
});

Python

weavz-io-sdk

Pythonic client with generated Pydantic input models and httpx under the hood. Designed for AI agent frameworks and backend services.

from weavz_sdk import WeavzClient
from weavz_sdk.integrations import SlackSendChannelMessageInput

client = WeavzClient(api_key="wvz_your_api_key")
workspace_id = "550e8400-e29b-41d4-a716-446655440000"

# Validate, then execute an action
result = client.actions.execute_typed(
    integration_name="slack",
    action_name="send_channel_message",
    workspace_id=workspace_id,
    integration_alias="office_slack",
    input=SlackSendChannelMessageInput(
        channel="#general",
        text="Hello from the Python SDK!",
    ),
)

# Manage connections
connections = client.connections.list(
    integration_name="slack",
)

# Create an MCP server
server = client.mcp_servers.create(
    name="My Server",
    workspace_id=workspace_id,
    mode="TOOLS",
)

What you can do

The SDKs are not only action wrappers. They let your product embed the full Weavz setup path behind your own onboarding, dashboards, and agent harnesses.

Provision customer workspaces

Create one scoped environment per customer, team, project, or agent. Credentials, aliases, state, approvals, and audit stay inside that boundary.

TS await client.workspaces.create({ name: "Acme Agent Workspace", slug: "acme-agents" })PY client.workspaces.create(name="Acme Agent Workspace", slug="acme-agents")

Mount approved app access

Add Slack, Gmail, HubSpot, files, state, browser, and custom APIs as stable workspace aliases your product and agents can call.

TS await client.workspaces.addIntegration(workspaceId, { integrationName: "slack", alias: "customer_slack" })PY client.workspaces.add_integration(workspace_id, integration_name="slack", integration_alias="customer_slack")

Generate hosted connect links

Register end users, then send them connect URLs for OAuth, API keys, and customer-owned accounts without building every auth flow yourself.

TS await client.endUsers.createConnectToken(endUserId, { workspaceIntegrationId })PY client.end_users.create_connect_token(end_user_id, workspace_integration_id=workspace_integration_id)

Create custom MCP servers

Programmatically create Tool Mode or Code Mode MCP servers for each workspace and expose only the integrations the agent should see.

TS await client.mcpServers.create({ name: "Customer Agent Server", workspaceId, mode: "CODE" })PY client.mcp_servers.create(name="Customer Agent Server", workspace_id=workspace_id, mode="CODE")

Issue scoped MCP tokens

Generate per-user tokens for your own harness, remote MCP clients, coding agents, and framework runtimes.

TS await client.mcpServers.createBearerToken(serverId, { endUserId })PY client.mcp_servers.create_bearer_token(server_id, end_user_id=end_user_id)

Execute governed actions

Call typed actions directly, or let agents execute through MCP while Human Gates, input partials, files, state, and audit stay attached.

TS await client.actions.execute("slack", "send_channel_message", { workspaceId, integrationAlias: "customer_slack", input })

PY client.actions.execute_typed("slack", "send_channel_message", workspace_id=workspace_id, input=input)

Every resource, one client

Every action, connection, MCP server, approval, trigger, end user, and runtime primitive is documented, generated where possible, and one import away.

Actions

Execute configured integration actions with TypeScript input types, Python Pydantic validation, and one client for the apps your agents need.

Connections

Create, list, and manage OAuth2 and API key connections. Generate hosted connect tokens for your end users.

MCP Servers

Create and configure MCP servers programmatically. Add tools, set modes, and manage access tokens for agent workspaces.

Triggers

Enable webhook, app-webhook, and polling triggers. Subscribe to events from any connected service.

Workspaces

Manage workspaces, integrations, and environment isolation. Configure connection strategies per integration.

End Users

Create and manage end user identities. Generate connect portal tokens for self-service connection management.

Partials

Create and manage input partials. Pre-fill parameters, enforce values, and control what agents can modify.

Workspace Integrations

Configure integrations per workspace. Set connection strategies, action whitelists, and aliases.

Ready to try it out?

Get started now

@weavz-io/sdk weavz-io-sdk

Start building today

20,000 free actions/month. Install the SDK, create an API key, and start executing actions in minutes.

Get Your API Key Quick Start Guide

Embed governed app accessfrom your backend