Your first tool call.

1. Create a project and a connection

Finish setup, sign in, and create a project from the sidebar. Save a provider API key in Connections. Saving does not verify the key or make a billable request. Use Test connection for supported providers; it makes a small authenticated read and may consume provider quota. Other services can be tested with an explicitly chosen Playground action.

Create a Connect key with read and execute permissions. Store it as CONNECT_API_KEY in your agent’s environment. The creation dialog includes ready-to-copy MCP configuration and a REST example for this site. These include your complete key and are shown only once.

2. Discover and inspect

Your Connect key selects its project. Search the catalog, then inspect a tool’s input schema.

curl 'http://localhost:3000/api/v1/tools?q=search' -H "Authorization: Bearer $CONNECT_API_KEY"

curl 'http://localhost:3000/api/v1/tools/tavily.search' -H "Authorization: Bearer $CONNECT_API_KEY"

3. Execute a tool

Playground supports searchable tool selection, input fields and JSON editing, local schema validation, and generated REST, TypeScript and MCP request examples. Review the provider connection and arguments before executing; examples never run automatically.

Contract tested means automated schema and request checks with synthetic responses. Live verified records a particular action, date and account scenario. Neither label certifies every endpoint or permission for that provider. Inspect the evidence in Catalog or Playground.

Named actions such as taskade.create_task accept validated inputs like project_id and content. Connect supplies the provider method, API path, and credentials. Named actions appear first when available; fields with defaults can be omitted.

A provider’s api_request tool accepts its documented HTTP method, full API path, query, JSON body, and optional version headers. The API host and credentials come from Connect. Such tools can modify or delete provider data; use tool allowlists and provider-side scopes to limit access.

Use the saved connection ID and the arguments from the tool schema. Results contain id, toolId, data, durationMs, and activityRecorded. Provider payloads remain in data.

curl 'http://localhost:3000/api/v1/tools/tavily.search/execute' -H "Authorization: Bearer $CONNECT_API_KEY" -H 'Content-Type: application/json' -d '{"connectionId":"YOUR_CONNECTION_ID","arguments":{"query":"Agent tool discovery","max_results":5}}'

TypeScript client

The client is available from src/sdk/index.ts and as a standalone package built from packages/sdk. The package has not been published. executeTyped checks built-in inputs; execute accepts dynamic and remote tool IDs. executeChecked validates core fields for 126 named actions. paginate supports 40 list actions, and waitForJob polls eight existing-job read actions across six providers with explicit limits. Other provider responses remain unknown. The package includes coverage metadata and REST, pagination, polling and MCP agent examples. See packages/sdk/README.md for packaging, coverage, cancellation and limits.

import { ConnectClient } from './src/sdk/index.ts';

const connect = new ConnectClient({
  baseUrl: 'http://localhost:3000',
  apiKey: process.env.CONNECT_API_KEY!,
});

const tools = await connect.listTools({ query: 'search' });
const result = await connect.executeTyped('tavily.search', {
  connectionId: 'YOUR_CONNECTION_ID',
  arguments: { query: 'Agent tool discovery', max_results: 5 },
});

Connect an MCP client

Stateless Streamable HTTP is available at /api/mcp. Supply a Connect project key in the Authorization header. Session cookies and OAuth are not supported here.

{
  "mcpServers": {
    "connect": {
      "url": "http://localhost:3000/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_CONNECT_API_KEY"
      }
    }
  }
}

Use connect.search_tools, connect.inspect_tool, and connect.execute_tool. Search returns a bounded set of summaries; inspect retrieves a full input schema. This avoids loading the entire catalog into your agent’s context. Add ?mode=direct to expose individual tools with connectionId and arguments inputs; that catalog is paginated in groups of 100. connect.project reads connections, activity, and usage; management operations require manage permission.

{
  "toolId": "tavily.search",
  "connectionId": "YOUR_CONNECTION_ID",
  "arguments": {
    "query": "Agent tool discovery",
    "max_results": 5
  }
}

REST reference

Download the OpenAPI document. It includes typed input schemas and examples for every built-in tool. Tool grants are still enforced; inclusion in public documentation does not grant access.

Paths start at /api/v1. API keys are restricted to one project. Only signed-in browser sessions can create projects or initialize storage.

Browser sessions supply ?projectId=YOUR_PROJECT_ID on tool endpoints. Keys infer the project. Errors return an error object with code, message, and requestId.

Current limits

25 projects per account. 1,000 connections and 50 keys per project. 60 executions, connection checks or MCP syncs per project per minute. Calls time out after 45 seconds, with a 2 MB response limit. Remote MCP imports allow 100 tools per server. Usage summarizes the latest 100 calls; it is not a billing report.

Remote MCP servers require HTTPS on port 443, an allowed public DNS origin, and bearer-key or no authentication. No stdio, legacy SSE transport, OAuth, or URL-embedded credentials. The upstream server validates imported tool arguments.