Quick Start

Connect Slack, send a message, and serve MCP tools in under 5 minutes.

This guide walks you through connecting Slack, executing an action, and setting up an MCP server. By the end, you'll have a working integration that AI agents can use.

Prerequisites

A Weavz account with an API key (Installation)
A Slack workspace you can connect (Weavz provides the OAuth app — no setup needed)

Create a Workspace

Workspaces scope your integrations, connections, and MCP servers. Create one to get started.

Navigate to Workspaces in the sidebar
Click Create Workspace
Enter the name "My Workspace" and slug my-workspace
Click Create

bash

curl -X POST https://api.weavz.io/api/v1/workspaces \
  -H "Authorization: Bearer wvz_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My Workspace",
    "slug": "my-workspace"
  }'

typescript

import { WeavzClient } from '@weavz/sdk'
 
const client = new WeavzClient({ apiKey: 'wvz_your_api_key' })
 
const { workspace } = await client.workspaces.create({
  name: 'My Workspace',
  slug: 'my-workspace',
})
 
console.log(`Workspace created: ${workspace.id}`)

python

from weavz_sdk import WeavzClient
 
client = WeavzClient(api_key="wvz_your_api_key")
 
result = client.workspaces.create(name="My Workspace", slug="my-workspace")
workspace = result["workspace"]
 
print(f"Workspace created: {workspace['id']}")

typescript

const res = await fetch('https://api.weavz.io/api/v1/workspaces', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer wvz_your_api_key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ name: 'My Workspace', slug: 'my-workspace' }),
})
 
const { workspace } = await res.json()
console.log(`Workspace created: ${workspace.id}`)

python

import httpx
 
res = httpx.post(
    "https://api.weavz.io/api/v1/workspaces",
    headers={"Authorization": "Bearer wvz_your_api_key"},
    json={"name": "My Workspace", "slug": "my-workspace"},
)
 
workspace = res.json()["workspace"]
print(f"Workspace created: {workspace['id']}")

Connect Slack

Weavz provides platform OAuth apps for services like Slack, so you don't need to create your own. Just open the hosted connect popup, log in to Slack, and authorize.

Open your workspace and go to the Connections tab
Click Create Connection
Select Slack from the integration picker
Click Authorize — a popup opens with Slack's consent screen
Approve access — the popup closes and your connection appears in the list

bash

# Create a connect token
curl -X POST https://api.weavz.io/api/v1/connect/token \
  -H "Authorization: Bearer wvz_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "integrationName": "slack",
    "connectionName": "My Slack",
    "externalId": "my_slack",
    "workspaceId": "YOUR_WORKSPACE_ID"
  }'

The response contains token, connectUrl, and expiresAt. Open the connectUrl in a browser popup to complete authorization.

typescript

// Step 1: Create a connect session
const session = await client.connect.createToken({
  integrationName: 'slack',
  connectionName: 'My Slack',
  externalId: 'my_slack',
  workspaceId: workspace.id,
})
 
// Step 2: Open the popup
const result = await client.connect.popup({
  token: session.token,
  connectUrl: session.connectUrl,
})
 
console.log(`Connected: ${result.connection.id}`)

python

# Create a connect token (open connectUrl in a browser)
result = client.connect.create_token(
    integration_name="slack",
    connection_name="My Slack",
    external_id="my_slack",
    workspace_id=workspace["id"],
)
# result contains: token, connectUrl, expiresAt
 
print(f"Open this URL to authorize: {result['connectUrl']}")
# Open result["connectUrl"] in a browser popup

typescript

// Create a connect token
const res = await fetch('https://api.weavz.io/api/v1/connect/token', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer wvz_your_api_key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    integrationName: 'slack',
    connectionName: 'My Slack',
    externalId: 'my_slack',
    workspaceId: 'YOUR_WORKSPACE_ID',
  }),
})
 
const { token, connectUrl } = await res.json()
// Open connectUrl in a browser popup to complete authorization

python

import httpx
 
res = httpx.post(
    "https://api.weavz.io/api/v1/connect/token",
    headers={"Authorization": "Bearer wvz_your_api_key"},
    json={
        "integrationName": "slack",
        "connectionName": "My Slack",
        "externalId": "my_slack",
        "workspaceId": "YOUR_WORKSPACE_ID",
    },
)
 
data = res.json()
print(f"Open this URL to authorize: {data['connectUrl']}")

Send a Slack Message

Now use that connection to send a message to a Slack channel.

Open the Playground from the sidebar
Select your workspace from the dropdown
Pick the Slack integration
Choose the Send Channel Message action
Enter a channel name and message text
Click Execute and view the result

bash

curl -X POST https://api.weavz.io/api/v1/actions/execute \
  -H "Authorization: Bearer wvz_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "integrationName": "slack",
    "actionName": "send_channel_message",
    "input": {
      "channel": "#general",
      "text": "Hello from Weavz!"
    },
    "workspaceId": "YOUR_WORKSPACE_ID",
    "connectionExternalId": "my_slack"
  }'

typescript

const { output } = await client.actions.execute('slack', 'send_channel_message', {
  input: {
    channel: '#general',
    text: 'Hello from Weavz!',
  },
  workspaceId: workspace.id,
  connectionExternalId: 'my_slack',
})
 
console.log('Message sent:', output)

python

result = client.actions.execute(
    "slack",
    "send_channel_message",
    input={"channel": "#general", "text": "Hello from Weavz!"},
    workspace_id=workspace["id"],
    connection_external_id="my_slack",
)
 
print("Message sent:", result["output"])

typescript

const res = await fetch('https://api.weavz.io/api/v1/actions/execute', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer wvz_your_api_key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    integrationName: 'slack',
    actionName: 'send_channel_message',
    input: { channel: '#general', text: 'Hello from Weavz!' },
    workspaceId: 'YOUR_WORKSPACE_ID',
    connectionExternalId: 'my_slack',
  }),
})
 
const { output } = await res.json()
console.log('Message sent:', output)

python

res = httpx.post(
    "https://api.weavz.io/api/v1/actions/execute",
    headers={"Authorization": "Bearer wvz_your_api_key"},
    json={
        "integrationName": "slack",
        "actionName": "send_channel_message",
        "input": {"channel": "#general", "text": "Hello from Weavz!"},
        "workspaceId": "YOUR_WORKSPACE_ID",
        "connectionExternalId": "my_slack",
    },
)
 
print("Message sent:", res.json()["output"])

The response contains the Slack API result:

json

{
  "success": true,
  "output": {
    "ok": true,
    "channel": "C01234567",
    "ts": "1234567890.123456",
    "message": {
      "text": "Hello from Weavz!",
      "type": "message"
    }
  }
}

Create an MCP Server

MCP servers let AI agents use your integrations as tools. Create one and add the Slack integration.

Navigate to MCP Servers in the sidebar
Click Create Server
Enter the name "My AI Tools", select TOOLS mode, and pick your workspace
Click Create
On the server detail page, click Add Tool
Select Slack and the Send Channel Message action
Choose your Slack connection
Copy the MCP endpoint and bearer token from the server details

bash

# Create the MCP server
curl -X POST https://api.weavz.io/api/v1/mcp/servers \
  -H "Authorization: Bearer wvz_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My AI Tools",
    "mode": "TOOLS",
    "workspaceId": "YOUR_WORKSPACE_ID"
  }'

bash

# Add Slack tools (use the serverId from the response above)
curl -X POST https://api.weavz.io/api/v1/mcp/servers/{serverId}/tools \
  -H "Authorization: Bearer wvz_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "integrationName": "slack",
    "actionName": "send_channel_message",
    "connectionId": "CONNECTION_ID"
  }'

typescript

const { server, bearerToken, mcpEndpoint } = await client.mcpServers.create({
  name: 'My AI Tools',
  mode: 'TOOLS',
  workspaceId: workspace.id,
})
 
await client.mcpServers.addTool(server.id, {
  integrationName: 'slack',
  actionName: 'send_channel_message',
  connectionId: session.connection.id,
})
 
console.log(`MCP endpoint: ${mcpEndpoint}`)
console.log(`Bearer token: ${bearerToken}`)

python

result = client.mcp_servers.create(
    name="My AI Tools",
    mode="TOOLS",
    workspace_id=workspace["id"],
)
 
server = result["server"]
bearer_token = result["bearerToken"]
mcp_endpoint = result["mcpEndpoint"]
 
client.mcp_servers.add_tool(
    server["id"],
    integration_name="slack",
    action_name="send_channel_message",
    connection_id="CONNECTION_ID",
)
 
print(f"MCP endpoint: {mcp_endpoint}")
print(f"Bearer token: {bearer_token}")

typescript

const serverRes = await fetch('https://api.weavz.io/api/v1/mcp/servers', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer wvz_your_api_key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'My AI Tools',
    mode: 'TOOLS',
    workspaceId: 'YOUR_WORKSPACE_ID',
  }),
})
 
const { server, bearerToken, mcpEndpoint } = await serverRes.json()
 
await fetch(`https://api.weavz.io/api/v1/mcp/servers/${server.id}/tools`, {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer wvz_your_api_key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    integrationName: 'slack',
    actionName: 'send_channel_message',
    connectionId: 'CONNECTION_ID',
  }),
})

python

server_res = httpx.post(
    "https://api.weavz.io/api/v1/mcp/servers",
    headers={"Authorization": "Bearer wvz_your_api_key"},
    json={
        "name": "My AI Tools",
        "mode": "TOOLS",
        "workspaceId": "YOUR_WORKSPACE_ID",
    },
)
 
data = server_res.json()
server_id = data["server"]["id"]
bearer_token = data["bearerToken"]
mcp_endpoint = data["mcpEndpoint"]
 
httpx.post(
    f"https://api.weavz.io/api/v1/mcp/servers/{server_id}/tools",
    headers={"Authorization": "Bearer wvz_your_api_key"},
    json={
        "integrationName": "slack",
        "actionName": "send_channel_message",
        "connectionId": "CONNECTION_ID",
    },
)
 
print(f"MCP endpoint: {mcp_endpoint}")
print(f"Bearer token: {bearer_token}")

Connect an AI Client

Use the MCP server endpoint and bearer token to connect an AI client.

Add to your Claude Desktop configuration (claude_desktop_config.json):

json

{
  "mcpServers": {
    "weavz": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://api.weavz.io/api/v1/mcp/servers/{serverId}/protocol",
        "--header",
        "Authorization: Bearer mcp_your_bearer_token"
      ]
    }
  }
}

Add to your Cursor MCP settings:

json

{
  "mcpServers": {
    "weavz": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://api.weavz.io/api/v1/mcp/servers/{serverId}/protocol",
        "--header",
        "Authorization: Bearer mcp_your_bearer_token"
      ]
    }
  }
}

Now ask Claude or Cursor to "send a message to #general in Slack" and watch it use your MCP tools.

What's Next

You've connected Slack via OAuth, sent a message, and set up an MCP server. Here's where to go from here:

Connections — learn about auth types, multi-tenant scoping, and the hosted connect flow
Actions — explore action execution patterns and input schemas
MCP Servers — configure TOOLS and CODE modes
Input Partials — save parameter presets and enforce values
Triggers — receive real-time events from integrations
Integrations — browse all 500+ available integrations