Built for integration-heavy products

From connection management to code execution — a complete integration platform that runs at the edge.

Connections

Secure connection management

OAuth2 PKCE flows, API key auth, and custom authentication — all with AES-256 encrypted credential storage. Fine-grained control with 4 connection policies per piece per project.

OAuth2 PKCE with popup flow — no redirect configuration needed
4 connection policies: Enforced Org, Enforced Project, User Required, User With Default
Encrypted at rest with per-environment encryption keys
Multi-tenant isolation — credentials scoped to org + project

// Create a connection via API
await fetch("/api/v1/connections", {
  method: "POST",
  headers: { "Authorization": "Bearer wvz_..." },
  body: JSON.stringify({
    pieceName: "slack",
    displayName: "Team Slack",
    value: { access_token: "xoxb-..." }
  })
});

MCP Servers

AI-native tool serving

Expose integrations as MCP tools that AI agents discover and call automatically. Two modes: TOOLS for standard tool definitions, CODE for context-efficient meta-tools.

TOOLS mode — each action becomes a discoverable tool with full JSON Schema
CODE mode — 3 meta-tools replace 200+ tool definitions (80-98% context reduction)
Auto-generated helper tools for dropdown properties
Bearer token auth for MCP clients

// AI agent connects via MCP protocol
const tools = await mcp.listTools();
// TOOLS mode: 200+ individual tools
// CODE mode: 3 meta-tools

// CODE mode workflow:
await mcp.callTool("weavz_search", { query: "slack" });
await mcp.callTool("weavz_read_api", { piece: "slack" });
await mcp.callTool("weavz_execute", {
  code: `await weavz.slack.send_message({
    channel: "#general", text: "Hello!"
  })`
});

Triggers

Real-time event delivery

Webhook and polling triggers with built-in deduplication. Subscribe to events from any connected service and receive real-time notifications.

Webhook triggers for instant event delivery
Polling triggers with configurable intervals and smart dedup
Event deduplication prevents duplicate processing
Trigger payloads delivered to your webhook URL or queued

// Enable a trigger
await fetch("/api/v1/triggers/enable", {
  method: "POST",
  headers: { "Authorization": "Bearer wvz_..." },
  body: JSON.stringify({
    pieceName: "github",
    triggerName: "new_pull_request",
    input: { repo: "myorg/myrepo" },
    webhookUrl: "https://myapp.com/webhook"
  })
});

Code Sandbox

Sandboxed code execution

Run custom JavaScript, Python, and Shell scripts in isolated sandbox environments. QuickJS WASM for lightweight tasks, CF Sandbox containers for full runtime access.

QuickJS WASM — in-process, zero-infra, sub-millisecond startup
CF Sandbox containers — full Node.js runtime with filesystem and network
Persistent storage via weavz.$storage backed by R2/S3
Action tracing — see exactly which API calls your code made

// Execute code in sandbox
await mcp.callTool("weavz_execute", {
  code: `
    // Fetch from Google Sheets
    const rows = await weavz.google_sheets
      .get_rows({ spreadsheet: "1Bx..." });

    // Transform and send to Slack
    const summary = rows.map(r => r.name).join(", ");
    await weavz.slack.send_message({
      channel: "#updates",
      text: \`New entries: \${summary}\`
    });

    // Persist state for next run
    await weavz.$storage.write("last_sync.json",
      JSON.stringify({ timestamp: Date.now() })
    );
  `
});

Multi-Tenant

Built for SaaS products

Organizations, projects, role-based access, API keys, and member management — designed for embedding integrations into your product.

Organizations with member invite and role management
Projects for environment isolation (dev, staging, prod)
API keys with org-scoped permissions
Enterprise service accounts available — contact sales

// API key authentication (backend)
await fetch("/api/v1/actions/execute", {
  headers: {
    "Authorization": "Bearer wvz_your_api_key"
  },
  body: JSON.stringify({
    pieceName: "hubspot",
    actionName: "create_contact",
    input: { email: "user@example.com" }
  })
});

Global Edge

Built on Cloudflare Workers

Weavz runs on Cloudflare Workers for global edge delivery with auto-scaling and zero cold starts. Need a private cloud deployment? Contact our sales team.

Global edge — auto-scaling, zero cold starts, 300+ PoPs
Provider abstraction — swap queue, cache, storage implementations
Enterprise SLA and dedicated infrastructure available
Private cloud deployment — contact sales for details

// Connect via MCP protocol
const client = new McpClient({
  url: "https://api.weavz.io/mcp/srv_abc123",
  token: "mcp_your_token_here"
});

// Or use the REST API
const response = await fetch(
  "https://api.weavz.io/api/v1/actions/execute",
  {
    headers: {
      "Authorization": "Bearer wvz_your_api_key"
    },
    body: JSON.stringify({
      pieceName: "slack",
      actionName: "send_message",
      input: { channel: "#general", text: "Hello!" }
    })
  }
);