Welcome, {session.email}

/sso/v1/oauth//callback`). 3. Paste it into your Google Cloud OAuth client under **Authorized redirect URIs** and save. 4. Back in Scalekit, enter the **Client ID** and **Client Secret** from your Google Cloud OAuth client. 5. Under **Scopes**, select at least `youtube.readonly`. Add `youtube` if your Actor needs write access (playlists, subscriptions). Add `yt-analytics.readonly` if you query analytics data. 6. Click **Save**. Note the **Connection name** (e.g., `youtube`) — your code must match it exactly. **Notion connection (per-user)** 1. Search for **Notion** and click **Create**. 2. Enter the **Client ID** and **Client Secret** from your Notion integration or OAuth app. 3. Scalekit pre-configures the redirect URI and scopes for Notion. Click **Save**. 4. Note the **Connection name** (e.g., `notion`). Scopes are locked at authorization time Scopes are locked in at authorization time. If you add scopes to a connection after a user has already authorized, their existing token does not gain the new scopes. Delete the connected account in Scalekit and have the user re-authorize to pick up the updated scopes. ### 2. Create the Apify Actor project [Section titled “2. Create the Apify Actor project”](#2-create-the-apify-actor-project) ```bash 1 apify create notion-youtube-agent -t project_empty 2 cd notion-youtube-agent 3 npm install @scalekit-sdk/node openai apify ``` Set your Scalekit credentials as Actor environment variables in the Apify Console under **Settings → Environment variables**: ```bash 1 SCALEKIT_ENV_URL=https://your-env.scalekit.dev 2 SCALEKIT_CLIENT_ID=skc_... 3 SCALEKIT_CLIENT_SECRET=your-secret ``` If your Actor creates new Notion pages (not just writing to existing ones), also set a default parent location. Without this, the Actor can only write to pages that already exist by exact title match. ```bash 1 NOTION_DEFAULT_PARENT_PAGE_ID=1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d ``` To find a Notion page ID: open the page in Notion, click **Share → Copy link**. The 32-character hex string at the end of the URL is the page ID. ### 3. Derive user identity from Apify’s runtime [Section titled “3. Derive user identity from Apify’s runtime”](#3-derive-user-identity-from-apifys-runtime) Apify exposes the identity of the account running the Actor through `Actor.getEnv()`. Use `userId` directly as the Scalekit connected-account identifier — no email field, no manual input. src/main.js ```js 1 import { Actor } from 'apify'; 2 3 await Actor.init(); 4 5 const { userId } = Actor.getEnv(); 6 7 // userId is stable per Apify account — the same user always gets the same token. 8 const notionIdentifier = userId; ``` `userId` is a stable opaque string that Apify sets for the account running the Actor. It persists across runs, so the first run that completes OAuth will find an active token on every subsequent run. Local development: userId is undefined `Actor.getEnv().userId` is `undefined` when you run the Actor locally with `apify run`. Use a hardcoded fallback for local development: ```js 1 const { userId } = Actor.getEnv(); 2 const notionIdentifier = userId ?? 'local-dev-user'; ``` ### 4. Choose shared vs per-user identifiers [Section titled “4. Choose shared vs per-user identifiers”](#4-choose-shared-vs-per-user-identifiers) Not every connector needs per-user isolation. A YouTube data connection used for research can be shared across all Actor runs with a hardcoded identifier. Only connectors that access private user data need per-user identifiers. src/main.js ```js 1 // Per-user: each Apify account connects their own Notion workspace. 2 const notionIdentifier = userId; 3 4 // Shared: one YouTube OAuth session used by all runs. 5 const youtubeIdentifier = 'shared-youtube'; ``` Hardcode the shared identifier in code — do not expose it as an input field. End users should not need to know it exists. ### 5. Ensure each connector is authorized [Section titled “5. Ensure each connector is authorized”](#5-ensure-each-connector-is-authorized) Before calling any API, check whether the connected account is active. If not, generate a magic link and wait for the user to complete the OAuth flow. src/notionAuth.js ```js 1 import { Actor } from 'apify'; 2 3 const ACTIVE = 1; 4 5 export async function ensureNotionConnected(scalekitActions, identifier, { 6 pollIntervalMs = 5_000, 7 timeoutMs = 300_000, 8 onMagicLink = async () => {}, 9 } = {}) { 10 const resp = await scalekitActions.getOrCreateConnectedAccount({ 11 connectionName: 'notion', 12 identifier, 13 }); 14 const account = resp.connectedAccount ?? resp; 15 16 if (account.status === ACTIVE) { 17 return account.id; 18 } 19 20 const { link } = await scalekitActions.getAuthorizationLink({ 21 connectionName: 'notion', 22 identifier, 23 }); 24 25 const markDone = await onMagicLink(link); 26 27 const deadline = Date.now() + timeoutMs; 28 29 while (Date.now() < deadline) { 30 await sleep(pollIntervalMs); 31 32 const pollResp = await scalekitActions.getOrCreateConnectedAccount({ 33 connectionName: 'notion', 34 identifier, 35 }); 36 const polled = pollResp.connectedAccount ?? pollResp; 37 38 if (polled.status === ACTIVE) { 39 markDone?.(); 40 await Actor.setStatusMessage('Notion authorized — proceeding.'); 41 return polled.id; 42 } 43 } 44 45 throw new Error(`Timed out waiting for Notion authorization.`); 46 } 47 48 function sleep(ms) { 49 return new Promise(resolve => setTimeout(resolve, ms)); 50 } ``` The same pattern applies to every connector. Copy the function, change `connectionName`, and pass in the appropriate identifier. ### 6. Surface auth as a live interactive page [Section titled “6. Surface auth as a live interactive page”](#6-surface-auth-as-a-live-interactive-page) Printing a raw magic link to the console or burying it in JSON output creates a poor experience. Apify Actors can start an HTTP server on `ACTOR_WEB_SERVER_PORT` (default `4321`), and Apify automatically exposes it as a public URL while the run is active. Use this to serve a branded OAuth consent page. src/authServer.js ```js 1 import http from 'http'; 2 import { Actor } from 'apify'; 3 4 const PORT = parseInt(process.env.ACTOR_WEB_SERVER_PORT ?? '4321', 10); 5 6 let server = null; 7 8 export function getLiveViewUrl() { 9 const { actorId, actorRunId } = Actor.getEnv(); 10 return `https://${actorId}--${actorRunId}-${PORT}.runs.apify.net`; 11 } 12 13 export async function serveAuthPage(link, serviceName) { 14 let html = buildAuthPage(link, serviceName); 15 16 if (server) server.close(); 17 server = http.createServer((_req, res) => { 18 res.writeHead(200, { 'Content-Type': 'text/html' }); 19 res.end(html); 20 }); 21 server.listen(PORT); 22 23 return { 24 liveViewUrl: getLiveViewUrl(), 25 markDone: () => { html = buildDonePage(serviceName); }, 26 }; 27 } 28 29 function buildAuthPage(link, serviceName) { 30 return ` 31 32 33 34 Authorize ${serviceName} 35 43 44 45

🔐 Connect ${serviceName}

Click below to authorize access to your ${serviceName} account. 48 The actor will continue automatically once you complete authorization.

49 Authorize ${serviceName} → 50

51 52 `; 53 } 54 55 function buildDonePage(serviceName) { 56 return ` 57 58 ${serviceName} Authorized 59 60

✅ ${serviceName} Authorized

Returning to task — you can close this tab.

62 63 `; 64 } ``` The live view URL follows this pattern: ```text 1 https://{actorId}--{actorRunId}-{PORT}.runs.apify.net ``` Both `actorId` and `actorRunId` come from `Actor.getEnv()` — the same call that gives you `userId`. ### 7. Wire auth into the Actor entry point [Section titled “7. Wire auth into the Actor entry point”](#7-wire-auth-into-the-actor-entry-point) Pass the live view callback into `ensureNotionConnected`. The callback starts the HTTP server, stores the `markDone` function, and returns it so the polling loop can update the page when auth completes. src/main.js ```js 1 import { Actor } from 'apify'; 2 import { ScalekitClient } from '@scalekit-sdk/node'; 3 import { ensureNotionConnected } from './notionAuth.js'; 4 import { serveAuthPage } from './authServer.js'; 5 6 await Actor.init(); 7 8 const input = await Actor.getInput(); 9 const { task } = input; 10 11 const { userId } = Actor.getEnv(); 12 const notionIdentifier = userId; 13 const youtubeIdentifier = 'shared-youtube'; 14 15 const scalekit = new ScalekitClient( 16 process.env.SCALEKIT_ENV_URL, 17 process.env.SCALEKIT_CLIENT_ID, 18 process.env.SCALEKIT_CLIENT_SECRET, 19 ); 20 21 await ensureNotionConnected(scalekit.actions, notionIdentifier, { 22 onMagicLink: async (link) => { 23 const { liveViewUrl, markDone } = await serveAuthPage(link, 'Notion'); 24 25 // Store the live view URL in OUTPUT so the Apify UI shows a clickable link. 26 await Actor.setValue('OUTPUT', { 27 status: 'AWAITING_NOTION_AUTH', 28 authPageUrl: liveViewUrl, 29 message: 'Open authPageUrl in your browser to authorize Notion.', 30 }); 31 32 await Actor.setStatusMessage(`ACTION REQUIRED: Authorize Notion → ${liveViewUrl}`); 33 34 return markDone; 35 }, 36 }); 37 38 // ... run the agent, push results ``` End-user experience after this change: 1. User starts the Actor run and types their task 2. **Output** panel immediately shows a clickable `authPageUrl` 3. User opens the URL and sees a branded “Authorize Notion →” button 4. After completing OAuth, the page updates to ”✅ Notion Authorized” 5. The Actor continues automatically — no re-run needed ### 8. Design the input schema for end users [Section titled “8. Design the input schema for end users”](#8-design-the-input-schema-for-end-users) The Actor’s input form should show only what the end user actually needs to provide. All auth identifiers, LLM config, and internal settings stay out of the form. .actor/input\_schema.json ```json 1 { 2 "title": "Notion + YouTube AI Agent", 3 "type": "object", 4 "schemaVersion": 1, 5 "properties": { 6 "task": { 7 "title": "Task", 8 "type": "string", 9 "description": "Natural language task for the agent. Examples: 'List the 5 most recently edited pages in my Notion workspace' or 'Search YouTube for React tutorial channels and append the top 10 to my Research page'.", 10 "editor": "textarea" 11 } 12 }, 13 "required": ["task"] 14 } ``` By default the Actor uses [Apify’s OpenRouter proxy](https://apify.com/apify/openrouter) for LLM inference, authenticated via `APIFY_TOKEN` (which Apify sets automatically). No external API key is needed — LLM costs are billed to the user’s Apify credits. If your Actor needs to support a custom LLM endpoint, add an optional `llmApiKey` field and detect the endpoint at runtime. Everything else — `notionIdentifier`, `youtubeIdentifier`, timeouts, model name, base URL — is either derived at runtime (`userId`) or hardcoded and deployed as an Actor environment variable. ### 9. Testing [Section titled “9. Testing”](#9-testing) Run locally: ```bash 1 apify run ``` Provide input in `storage/key_value_stores/default/INPUT.json`: ```json 1 { 2 "task": "List the 5 most recently edited pages in my Notion workspace" 3 } ``` Because `Actor.getEnv().userId` is `undefined` locally, the `notionIdentifier` falls back to your local development value. After you confirm the flow works, deploy to Apify: ```bash 1 apify push ``` On the first cloud run, the Actor outputs an `authPageUrl`. Open it, click **Authorize Notion**, and complete the OAuth flow. The Actor polls and continues automatically. On every subsequent run for the same Apify account, the token is already active and the auth step is skipped entirely. ## Common mistakes [Section titled “Common mistakes”](#common-mistakes) ## Production notes [Section titled “Production notes”](#production-notes) **Token persistence across runs** — Scalekit stores the OAuth token server-side keyed by `(connectionName, identifier)`. As long as `userId` is stable (it is), the user only completes the OAuth flow once. Subsequent runs call `getOrCreateConnectedAccount` and get an active account back immediately. **Token refresh** — Scalekit refreshes expired tokens automatically before returning them. You do not need to track expiry or call a refresh endpoint. **Re-authorization** — If a user revokes access in Notion’s settings, `getOrCreateConnectedAccount` returns a non-active account. The Actor generates a new magic link automatically. No code change required — the polling loop handles it the same way as a first-time auth. **Shared connectors** — The `shared-youtube` identifier works because YouTube access is the same for all users (e.g., read-only public data). Any connector where all users share the same OAuth session can use a hardcoded identifier. Private data connectors — Notion, Gmail, GitHub — should always use a per-user identifier. **Input schema changes require a redeploy** — The Apify Console reads the input schema from the deployed build. Changes to `.actor/input_schema.json` only take effect after `apify push`. ## Next steps [Section titled “Next steps”](#next-steps) * **Add more per-user connectors** — The same `ensureConnected` + `onMagicLink` pattern works for any Scalekit connector. Add a `src/githubAuth.js` following the same structure as `notionAuth.js`. * **Use built-in actions** — For connectors with Scalekit built-in tools, replace manual API calls with `scalekit.actions.executeTool`. See [all supported connectors](/agentkit/connectors/). * **Extend the input schema** — Add optional fields like `maxIterations` or `llmModel` with defaults, so power users can tune the Actor without the defaults getting in the way for casual users. * **Review the agent auth quickstart** — For a broader overview of the connected-accounts model, see the [agent auth quickstart](/agentkit/quickstart/). --- # DOCUMENT BOUNDARY --- # Build a Vapi voice assistant with Scalekit > Use Vapi + Scalekit Virtual MCP for voice assistants to securely access any tool from large catalogs. Voice interfaces shine for hands-free, conversational access to data and actions. But giving a voice agent access to real tools (Gmail, Calendar, Slack, GitHub, Drive, CRM, Notion, and [many other connectors](/agentkit/connectors/)) introduces two hard problems: per-user authentication without leaking tokens to the LLM, and managing a large tool surface without overwhelming context windows or exposing everything to every user. Scalekit lets you: * Register built-in tools from connections and custom tools directly in the UI or code (see “Registering tools in the Scalekit UI” below). * Associate them with specific users via connections. * Use **Virtual MCP** to bundle hundreds or thousands of those registered tools into a single, scoped, per-user MCP endpoint that Vapi can discover dynamically. This cookbook walks through building a [Vapi](https://vapi.ai) voice assistant that can safely discover and use any tool (from a catalog of hundreds or thousands) using Scalekit’s tool registration + Virtual MCP. You can also call specific registered tools directly via Vapi Function tools if you don’t need dynamic discovery of many. The complete source is available in the [vapi-scalekit-voice-demo](https://github.com/scalekit-developers/vapi-scalekit-voice-demo) repository. ## What you are building [Section titled “What you are building”](#what-you-are-building) * Register and manage individual tools (built-in from connections or custom) directly in the Scalekit UI, and associate them with users/connections. * A **Vapi voice assistant** that understands natural language requests (e.g. “List my meetings this week”, “Find emails from Acme about the renewal”, “Summarize the last thread in #eng-updates on Slack”, “Show my open GitHub PRs”, “Find the latest proposal in Drive and email it to the team”). * **Dynamic tool discovery** via a Scalekit Virtual MCP — the assistant only sees the tools you explicitly scoped for that role (selected from the ones you registered). Vapi discovers these at call start via the MCP protocol. * **Per-user OAuth without custom code** — Scalekit handles authorization links, token storage, and refresh. Your app passes the user’s identifier. * **Access to any tool** — scoping + per-user tokens keep context small and access least-privilege even when the full catalog is huge. * A pattern you can extend to other voice platforms or agent frameworks by swapping the client. ## Prerequisites [Section titled “Prerequisites”](#prerequisites) * A Scalekit account with AgentKit enabled ([create one](https://app.scalekit.com)). * At least one connection configured (e.g. Google Calendar, Gmail) under **AgentKit → Connections**. See [Configure a connection](/agentkit/connections/). * A Vapi account and at least one assistant. * Node.js 18+ and the demo dependencies. * ngrok (or equivalent) for local webhook exposure during development. * Familiarity with basic voice agent concepts and OAuth flows. ## Environment variables [Section titled “Environment variables”](#environment-variables) The demo is configured via `.env.local` (copy it from `.env.example`). ```bash 1 cp .env.example .env.local ``` ### Variables present in the demo [Section titled “Variables present in the demo”](#variables-present-in-the-demo) | Variable | Required | Client (browser) | Purpose | | ----------------------------------------- | --------------- | ---------------- | ---------------------------------------------------------------------------------------- | | `NEXT_PUBLIC_VAPI_PUBLIC_KEY` | Yes | Yes | Initializes the Vapi Web SDK in the browser | | `NEXT_PUBLIC_VAPI_ASSISTANT_ID` | Yes | Yes | ID of the assistant to start voice calls against | | `VAPI_PRIVATE_KEY` | For API updates | No | Used server-side only to call Vapi APIs (create/update tools programmatically) | | `SCALEKIT_ENV_URL` | Yes | No | Base URL of your Scalekit environment | | `SCALEKIT_CLIENT_ID` | Yes | No | Scalekit API credential (public part) | | `SCALEKIT_CLIENT_SECRET` | Yes | No | Scalekit secret. Never ship to browser or commit | | `TEST_IDENTIFIER` | Yes | No (server) | The user identity (email / your ID) whose connections will be used | | `NEXT_PUBLIC_TEST_SCALEKIT_CONNECTION_ID` | Yes | Yes | Browser-safe copy of the identifier; passed in Vapi call `metadata` | | `SCALEKIT_MCP_CONFIG_ID` | For MCP | No | `cfg_...` ID of your Virtual MCP config (created in Scalekit dashboard) | | `NEXT_PUBLIC_SCALEKIT_MCP_SERVER_URL` | For MCP | Yes (url only) | The static base MCP server URL. Token is added at runtime via the `Authorization` header | **MCP-specific vars** (`SCALEKIT_MCP_CONFIG_ID` + `NEXT_PUBLIC_SCALEKIT_MCP_SERVER_URL`) are only needed when using the dynamic discovery MCP tool path (recommended when you want to expose many tools). They are not required for pure Function tool + `executeTool` mode. ### Running the token helper (demo) [Section titled “Running the token helper (demo)”](#running-the-token-helper-demo) After filling the MCP variables, generate a fresh token for Vapi: ```bash 1 python scripts/generate-mcp-token.py ``` (or `node --env-file=.env.local scripts/generate-mcp-token.js`) The script outputs the exact `server` object (url + Authorization header) you paste into the Vapi MCP tool form. ### What changes when you go live (production) [Section titled “What changes when you go live (production)”](#what-changes-when-you-go-live-production) In a real application you do **not** rely on a static `.env.local` for user identity or tokens: * **Identifier comes from runtime context** — After a real user authenticates in your app and authorizes their connections (Gmail etc.), you obtain their `identifier` from your session / database. Never use a hardcoded `TEST_IDENTIFIER`. * **Tokens are minted on the fly and short-lived** — When the user starts a voice call, your backend calls Scalekit to create a fresh session token for that specific identifier + config (see `app/api/scalekit/mcp-session/route.ts` and the Python script). Tokens typically live for minutes to an hour. * **MCP server configuration is injected dynamically** — * Demo: you manually copy-paste `server.url` and the `Authorization: Bearer ` header into the Vapi dashboard UI. * Production: your backend uses the **Vapi API** (authenticated with `VAPI_PRIVATE_KEY`) to create or patch the MCP tool on the assistant with the fresh per-call `server` object (containing the just-minted token). You can do this immediately before calling `vapi.start(...)` or via Vapi’s assistant update endpoints. The token never sits in your dashboard. * **Secrets stay server-side** — `SCALEKIT_CLIENT_SECRET` and `VAPI_PRIVATE_KEY` remain in your production environment variables / secret manager. Only non-sensitive values (`NEXT_PUBLIC_*` public keys, config IDs, base URLs) may be exposed to the client when truly required. * For non-MCP flows (Function tools), the webhook receives the identifier via Vapi `metadata` and performs minting + `executeTool` internally. This design means the same Virtual MCP config works for every user—you only swap the short-lived token and the acting identifier at call time. ## Registering tools in the Scalekit UI [Section titled “Registering tools in the Scalekit UI”](#registering-tools-in-the-scalekit-ui) You register and associate tools centrally in the Scalekit dashboard (no code required for built-ins): * **Set up a connection** (AgentKit → Connections): Choose Gmail, Google Calendar, GitHub, etc. Scalekit registers its built-in tools automatically (e.g. `googlecalendar_list_events`). You can browse and search the full catalog under **AgentKit → Tools** or inside the connection page. See the [full list of connectors](/agentkit/connectors/). * **Authorize for users**: Go to **AgentKit → Connected Accounts** (or during first use), authorize using your app’s `identifier` (e.g. `saif.shaik@scalekit.com`). This associates the tools with that user. The connection must show **Active**. * **Custom tools**: Define additional tools in your code (see [Build custom tools](/agentkit/tools/custom-tools)) using `actions.request` to call any provider API. They can be associated with connections and included in scopes. Once registered and associated, these tools are available for: * Direct calls via `executeTool` (e.g. from a Vapi Function tool webhook). * Inclusion in a **Virtual MCP** config so a single MCP endpoint can surface hundreds or thousands safely. This is key when you have many tools: you register/maintain them in the UI or code, then use vMCP to selectively expose subsets to your voice assistant without token bloat or over-privileging. ## Architecture overview [Section titled “Architecture overview”](#architecture-overview) ```plaintext 1 User (voice) 2 │ 3 ▼ 4 Vapi assistant (MCP tool configured) 5 │ (connects with per-user Bearer token) 6 ▼ 7 Scalekit Virtual MCP (scoped to role + user) 8 │ (only exposes allowed tools) 9 ▼ 10 Scalekit AgentKit (token vault + execute) 11 │ 12 ▼ 13 Real connectors (Gmail, Calendar, Slack, GitHub, ... — [many connectors](/agentkit/connectors/)) ``` Key differences from a naive “give the LLM every tool” approach: * Tool surface is defined once in the Virtual MCP config (least privilege). * Context size stays manageable (scoping reduces tokens). * Identity is enforced at the token level (no raw OAuth secrets reach the model or Vapi). ## Step 1: Create a scoped Virtual MCP (select from your registered tools) in Scalekit [Section titled “Step 1: Create a scoped Virtual MCP (select from your registered tools) in Scalekit”](#step-1-create-a-scoped-virtual-mcp-select-from-your-registered-tools-in-scalekit) 1. In the Scalekit dashboard go to **AgentKit → MCP Configs → Create Config**. 2. Give it a name (e.g. “voice-personal-assistant”). 3. Add connection tool mappings for the connectors you want. See the [full list of connectors](/agentkit/connectors/). Example for calendar + email (expand later with Slack, GitHub, Drive, etc.): ```yaml 1 connection_tool_mappings: 2 - connection_name: googlecalendar 3 tools: [googlecalendar_list_events, googlecalendar_create_event] 4 - connection_name: gmail 5 tools: [gmail_fetch_mails, gmail_send_mail] # start small! ``` 4. Save. Copy the **config ID** (e.g. `cfg_...`) and the generated **mcp\_server\_url**. ![Creating a Virtual MCP in the Scalekit dashboard](/.netlify/images?url=_astro%2Fvmcp-scalekit.DzqPxAS8.png\&w=3012\&h=1090\&dpl=6a7afd35ca95e20008d421ee) The screenshot above shows the Scalekit dashboard flow for creating the scoped Virtual MCP. This single config definition is reused for every user. You only change the token you mint at runtime. The scoping here is what lets you safely expose many tools without the LLM seeing everything. ## Step 2: Authorize connections for your test user [Section titled “Step 2: Authorize connections for your test user”](#step-2-authorize-connections-for-your-test-user) For the identifier you will use in the demo (e.g. your email): 1. Go to **AgentKit → Connected Accounts**. 2. Authorize the connections you mapped above. 3. Confirm they show **Active**. If any are inactive, the token mint will fail with a clear error and an auth link. ## Step 3: Wire the Vapi assistant [Section titled “Step 3: Wire the Vapi assistant”](#step-3-wire-the-vapi-assistant) You have two main options in Vapi, depending on whether you want dynamic discovery of many scoped tools or direct calls to specific ones. ### Option A: MCP tool for dynamic discovery (recommended when you have many tools) [Section titled “Option A: MCP tool for dynamic discovery (recommended when you have many tools)”](#option-a-mcp-tool-for-dynamic-discovery-recommended-when-you-have-many-tools) 1. In Vapi, create or edit an assistant. 2. Create a new **MCP** tool (not Function). 3. Configure it with the Scalekit Virtual MCP details: * **Server URL**: the `mcp_server_url` from Step 1 * **HTTP Headers** (look for the **Headers**, **Add Header**, or **Custom Headers** / `server.headers` section in the tool form in the Vapi dashboard): * Key: `Authorization` * Value: `Bearer ` 4. Attach the MCP tool to the assistant. 5. Update the system prompt to tell the model when and how to use tools (example in the demo repo). ![Registering the MCP tool in the Vapi dashboard](/.netlify/images?url=_astro%2Ftool-registration-scalekit.DMPxf1_w.png\&w=2988\&h=1182\&dpl=6a7afd35ca95e20008d421ee) The screenshot above illustrates where to configure the server URL and add the Authorization HTTP header in Vapi’s MCP tool form. ### Option B: Function tool for specific registered tools [Section titled “Option B: Function tool for specific registered tools”](#option-b-function-tool-for-specific-registered-tools) Create a **Function** tool in Vapi pointing to your webhook URL. The tool name must exactly match a tool you have registered or available in Scalekit (e.g. `googlecalendar_list_events`). Your webhook then calls `executeTool` for it. You now have a voice agent that can discover tools dynamically from the scoped MCP (or call specific ones directly). ## Step 4: Mint per-user tokens at runtime (the demo) [Section titled “Step 4: Mint per-user tokens at runtime (the demo)”](#step-4-mint-per-user-tokens-at-runtime-the-demo) See the dedicated [Environment variables](#environment-variables) section above for the full list and demo vs. production guidance. The demo (Next.js + Vapi Web SDK) shows the complete loop for testing: * User clicks “Start Voice Call” and passes `scalekitConnectionId` (the identifier) via Vapi call `metadata`. * The backend (or the helper script) mints a fresh short-lived session token for that identifier + your Virtual MCP config. * You supply the token via the `Authorization: Bearer ...` header so Vapi can connect to the scoped MCP endpoint with the correct identity. For quick local testing use the provided scripts (prominently shown in the demo UI): ```bash 1 python scripts/generate-mcp-token.py ``` See `scripts/generate-mcp-token.py` (recommended), `scripts/generate-mcp-token.js`, `app/api/scalekit/mcp-session/route.ts`, and the demo’s Virtual MCP panel for exact implementation and copyable output. Key pattern (what the script / route produces): ```json 1 { 2 "server": { 3 "url": "https://...scalekit.../mcp/v3/servers/...", 4 "headers": { 5 "Authorization": "Bearer " 6 } 7 } 8 } ``` In the demo you paste the `url` into Vapi’s MCP tool **Server URL** field and add the header manually (see Step 3). The UI and scripts make this easy to copy. ## Production note: tokens and config are injected at runtime [Section titled “Production note: tokens and config are injected at runtime”](#production-note-tokens-and-config-are-injected-at-runtime) In a real application you never manually edit the Vapi dashboard for each user or call: * Your backend mints the token **on the fly** (using the Scalekit SDK or direct call with management token) exactly when the user initiates the voice session. * You then use the Vapi API (authenticated with your `VAPI_PRIVATE_KEY`) to dynamically set or override the MCP tool’s `server` (url + Authorization header) on the assistant before starting the call. * The identifier always comes from the logged-in user context rather than a `TEST_IDENTIFIER` env var. Mint a session token (and build the `mcpConfig`) in your backend before each call. Node.js and Python match the demo stack. Go and Java are omitted — the Vapi demo and Virtual MCP token helpers are Node/Python only, and the high-level `create_session_token` API is currently documented for the Python SDK. * Node.js mint-token.ts ```ts 1 // The Node SDK does not expose actions.mcp.create_session_token yet. 2 // Mint via the management token + REST, as in the demo route. 3 try { 4 // Security: mint a short-lived, per-user token server-side so the credential 5 // never reaches the browser, Vapi dashboard, or the LLM. 6 const managementToken = await scalekit.getClientAccessToken(); 7 const base = process.env.SCALEKIT_ENV_URL!.replace(/\/$/, ''); 8 const tokenRes = await fetch( 9 `${base}/api/v1/actions/mcp/configs/${mcpConfigId}/session-tokens`, 10 { 11 method: 'POST', 12 headers: { 13 Authorization: `Bearer ${managementToken}`, 14 'Content-Type': 'application/json', 15 }, 16 body: JSON.stringify({ 17 identifier: userIdentifier, 18 expiry: '1h', 19 }), 20 }, 21 ); 22 if (!tokenRes.ok) { 23 throw new Error(await tokenRes.text()); 24 } 25 const tokenData = await tokenRes.json(); 26 const token = tokenData.token; 27 28 const mcpConfig = { 29 url: mcpServerUrl, 30 headers: { Authorization: `Bearer ${token}` }, 31 }; 32 33 // Pass mcpConfig to Vapi (via API or call start) 34 } catch (err) { 35 console.error('Token mint failed:', err); 36 } ``` * Python mint\_token.py ```python 1 from datetime import timedelta 2 3 try: 4 # Security: mint a short-lived, per-user token server-side so the credential 5 # never reaches the browser, Vapi dashboard, or the LLM. 6 token_response = scalekit_client.actions.mcp.create_session_token( 7 mcp_config_id=mcp_id, 8 identifier=user_identifier, 9 expiry=timedelta(hours=1), 10 ) 11 12 mcp_config = { 13 "url": mcp_server_url, 14 "headers": {"Authorization": f"Bearer {token_response.token}"}, 15 } 16 17 # use mcp_config with Vapi 18 except Exception as e: 19 print(f"Token mint failed: {e}") ``` The same Virtual MCP config (the `cfg_...` you created) is reused for everyone. Only the short-lived token and acting identifier change per user / per call. This is exactly what the demo’s `/api/scalekit/mcp-session` endpoint and the “In a real app” callout in the demo UI demonstrate. ## Step 5: Test the voice flow [Section titled “Step 5: Test the voice flow”](#step-5-test-the-voice-flow) 1. Start the demo: `npm run dev` + `ngrok http 3000`. 2. Update Vapi tool Server URL to your ngrok + `/api/vapi/webhook` (for the Function fallback) or point the MCP tool at the Scalekit URL + token. 3. In the browser: click **Start Voice Call**. 4. Speak natural requests. A few examples that work well with common scoped tools: **Calendar** * “What do I have on my calendar this week?” * “Find a 30-minute slot tomorrow afternoon for a sync with Priya” * “Add a meeting with the design team on Friday at 2pm” **Email (Gmail)** * “Find emails from Acme Corp” * “Summarize the latest thread with the legal team” * “Draft a polite reply to the last message from Sarah” **Slack** * “Summarize the latest messages in #product channel” * “Any mentions of the launch in Slack this morning?” **GitHub + Drive + cross-tool** * “Show my open pull requests” * “Find the Q3 roadmap in Drive and email a summary to the team” * “Check my calendar for tomorrow and email the attendees the agenda doc from Drive” The assistant should use the discovered tools, execute them via Scalekit (with your identity), and speak the results. Mix and match connectors (see [full list](/agentkit/connectors/)) that you’ve included in your Virtual MCP config. Watch the terminal for `[Vapi Webhook]` or MCP connection logs. ## Troubleshooting [Section titled “Troubleshooting”](#troubleshooting) | Symptom | Likely cause & fix | | ----------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | | Vapi can’t discover tools | Token expired or missing `Authorization: Bearer ` header. Regenerate and paste fresh. | | ”No connected account” when minting | User hasn’t authorized the connections in the Virtual MCP. Authorize in Scalekit → Connected Accounts. | | Agent ignores tools or hallucinates | System prompt doesn’t instruct tool use, or too many tools in scope. Tighten mappings in Virtual MCP config and strengthen prompt. | | 401 from Scalekit | Wrong identifier or connection not active for the config. Verify with `list_mcp_connected_accounts`. | See the demo repo for more. ## How this gives voice assistants access to any tool [Section titled “How this gives voice assistants access to any tool”](#how-this-gives-voice-assistants-access-to-any-tool) * **Scoping at config time** — the Virtual MCP only advertises the tools you mapped. The LLM never sees the rest of the catalog. * **Per-user tokens** — even when hundreds or thousands of tools exist, each call only carries the user’s authorized subset. * **Dynamic discovery** — Vapi fetches the current allowed tools at the start of the conversation. No static tool list to maintain. * **Token cost control** — fewer tools = dramatically smaller context. A huge catalog would be unusable; a small scoped set (e.g. 5–15 tools) is practical. **Real use case examples that become feasible only with scoping**: A sales rep might get “Gmail + Calendar + Salesforce + Slack” (8-12 tools). An engineer might get “GitHub + Drive + Slack + Gmail”. Both use the *same* underlying catalog, but each voice session only sees what that person is allowed to do. The same pattern works for any voice or chat platform that supports MCP clients. ## Security & compliance notes [Section titled “Security & compliance notes”](#security--compliance-notes) * Raw OAuth tokens never leave Scalekit. * Every tool call is audited with the acting user’s identity. * You can rotate or revoke access per connection without touching the agent. * Virtual MCP gives you an explicit allow-list instead of “all tools the user has ever connected”. ## Next steps & variations [Section titled “Next steps & variations”](#next-steps--variations) * Add more connectors (see the [full list](/agentkit/connectors/)) by extending the Virtual MCP mapping. * Switch voice platforms (replace Vapi with another MCP-capable voice or chat client). * Add a real user login flow so the identifier comes from your session instead of an env var. * Expose the same Virtual MCP to web, mobile, and voice clients from one config. * Combine with Scalekit’s user verification for stronger identity assurance. ## References [Section titled “References”](#references) * [Scalekit Virtual MCP docs](/agentkit/mcp/overview/) * [Vapi](https://vapi.ai) (see [MCP integration](https://docs.vapi.ai/tools/mcp)) * [AgentKit tool calling](/agentkit/tools/overview/) * Demo repo + recording linked above. See the [full demo source](https://github.com/scalekit-developers/vapi-scalekit-voice-demo) and the [Virtual MCP configuration guide](/agentkit/mcp/configure-mcp-server/). --- # DOCUMENT BOUNDARY --- # Building a Custom Organization Switcher > Learn how to build your own organization switcher UI for complete control over multi-tenant user experiences. When users belong to multiple organizations, the default Scalekit organization switcher handles most use cases. However, some applications require deeper integration—a custom switcher embedded directly in your app’s navigation, or a specialized UI that matches your design system. This guide shows you how to build your own organization switcher using Scalekit’s APIs. ## Why build a custom switcher? [Section titled “Why build a custom switcher?”](#why-build-a-custom-switcher) The default Scalekit-hosted switcher works well for most scenarios. Build a custom switcher when you need: * **In-app navigation**: Users switch organizations without leaving your application * **Custom branding**: The switcher matches your application’s design language * **Specialized workflows**: Your app needs org-specific logic during switches * **Reduced redirects**: Avoid sending users through the authentication flow for every switch ## How the custom switcher works [Section titled “How the custom switcher works”](#how-the-custom-switcher-works) Your application handles the entire switching flow: 1. User authenticates through Scalekit and receives a session 2. Your app fetches the user’s organizations via the User Sessions API 3. You render your own organization selector UI 4. When a user selects an organization, your app updates the active context This approach gives you full control over the UI and routing, but requires you to manage session state and organization context within your application. ## Fetch user organizations [Section titled “Fetch user organizations”](#fetch-user-organizations) The User Sessions API returns the `authenticated_organizations` field containing all organizations the user can access. Use this data to populate your switcher UI. * Node.js Express.js ```javascript 1 // Use case: Get user's organizations for your switcher UI 2 // Security: Always validate session ownership before returning org data 3 const session = await scalekit.session.getSession(sessionId); 4 5 // Extract organizations from the session response 6 const organizations = session.authenticated_organizations || []; 7 8 // Render your organization switcher with this data 9 res.json({ organizations }); ``` * Python Flask ```python 1 # Use case: Get user's organizations for your switcher UI 2 # Security: Always validate session ownership before returning org data 3 session = scalekit_client.sessions.get_session(session_id) 4 5 # Extract organizations from the session response 6 organizations = session.get('authenticated_organizations', []) 7 8 # Render your organization switcher with this data 9 return jsonify({'organizations': organizations}) ``` * Go Gin ```go 1 // Use case: Get user's organizations for your switcher UI 2 // Security: Always validate session ownership before returning org data 3 session, err := scalekitClient.Session().GetSession(ctx, sessionId) 4 if err != nil { 5 return err 6 } 7 8 // Extract organizations from the session response 9 organizations := session.AuthenticatedOrganizations 10 11 // Render your organization switcher with this data 12 c.JSON(http.StatusOK, gin.H{"organizations": organizations}) ``` * Java Spring ```java 1 // Use case: Get user's organizations for your switcher UI 2 // Security: Always validate session ownership before returning org data 3 Session session = scalekitClient.sessions().getSession(sessionId); 4 5 // Extract organizations from the session response 6 List organizations = session.getAuthenticatedOrganizations(); 7 8 // Render your organization switcher with this data 9 return ResponseEntity.ok(Map.of("organizations", organizations)); ``` The response includes organization IDs, names, and metadata for each organization the user can access. ## Add domain context [Section titled “Add domain context”](#add-domain-context) Enhance your switcher by displaying which domains are associated with each organization. Use the Domains API to fetch this information. ```javascript 1 // Example: Fetch domains for an organization 2 const domains = await scalekit.domain.listDomains('org_123'); 3 4 // Display "@acme.com" next to the organization name in your UI ``` This helps users quickly identify the correct organization, especially when they belong to organizations with similar names. ## Handle organization selection [Section titled “Handle organization selection”](#handle-organization-selection) When a user selects an organization in your custom switcher, update your application’s context. Store the active organization ID in session storage or a cookie, then use it for subsequent API calls. * Node.js Express.js ```javascript 1 // Use case: Store selected organization and fetch org-specific data 2 app.post('/api/select-organization', async (req, res) => { 3 const { organizationId } = req.body; 4 const sessionId = req.session.scalekitSessionId; 5 6 // Security: Verify the user belongs to this organization 7 const session = await scalekit.session.getSession(sessionId); 8 const hasAccess = session.authenticated_organizations.some( 9 org => org.id === organizationId 10 ); 11 12 if (!hasAccess) { 13 return res.status(403).json({ error: 'Unauthorized' }); 14 } 15 16 // Store the active organization in the user's session 17 req.session.activeOrganizationId = organizationId; 18 19 res.json({ success: true }); 20 }); ``` * Python Flask ```python 1 # Use case: Store selected organization and fetch org-specific data 2 @app.route('/api/select-organization', methods=['POST']) 3 def select_organization(): 4 data = request.get_json() 5 organization_id = data.get('organizationId') 6 session_id = session.get('scalekit_session_id') 7 8 # Security: Verify the user belongs to this organization 9 user_session = scalekit_client.sessions.get_session(session_id) 10 has_access = any( 11 org['id'] == organization_id 12 for org in user_session.get('authenticated_organizations', []) 13 ) 14 15 if not has_access: 16 return jsonify({'error': 'Unauthorized'}), 403 17 18 # Store the active organization in the user's session 19 session['active_organization_id'] = organization_id 20 21 return jsonify({'success': True}) ``` * Go Gin ```go 1 // Use case: Store selected organization and fetch org-specific data 2 func SelectOrganization(c *gin.Context) { 3 var req struct { 4 OrganizationID string `json:"organizationId"` 5 } 6 if err := c.BindJSON(&req); err != nil { 7 c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request"}) 8 return 9 } 10 11 sessionID := c.GetString("scalekitSessionID") 12 13 // Security: Verify the user belongs to this organization 14 session, err := scalekitClient.Session().GetSession(ctx, sessionID) 15 if err != nil { 16 c.JSON(http.StatusInternalServerError, gin.H{"error": "Session error"}) 17 return 18 } 19 20 hasAccess := false 21 for _, org := range session.AuthenticatedOrganizations { 22 if org.ID == req.OrganizationID { 23 hasAccess = true 24 break 25 } 26 } 27 28 if !hasAccess { 29 c.JSON(http.StatusForbidden, gin.H{"error": "Unauthorized"}) 30 return 31 } 32 33 // Store the active organization in the user's session 34 c.SetCookie("activeOrganizationID", req.OrganizationID, 3600, "/", "", true, true) 35 36 c.JSON(http.StatusOK, gin.H{"success": true}) 37 } ``` * Java Spring ```java 1 // Use case: Store selected organization and fetch org-specific data 2 @PostMapping("/api/select-organization") 3 public ResponseEntity selectOrganization( 4 @RequestBody Map request, 5 HttpSession httpSession 6 ) { 7 String organizationId = request.get("organizationId"); 8 String sessionId = (String) httpSession.getAttribute("scalekitSessionId"); 9 10 // Security: Verify the user belongs to this organization 11 Session session = scalekitClient.sessions().getSession(sessionId); 12 boolean hasAccess = session.getAuthenticatedOrganizations().stream() 13 .anyMatch(org -> org.getId().equals(organizationId)); 14 15 if (!hasAccess) { 16 return ResponseEntity.status(HttpStatus.FORBIDDEN) 17 .body(Map.of("error", "Unauthorized")); 18 } 19 20 // Store the active organization in the user's session 21 httpSession.setAttribute("activeOrganizationId", organizationId); 22 23 return ResponseEntity.ok(Map.of("success", true)); 24 } ``` Always verify that the user actually belongs to the organization they’re attempting to switch to. The `authenticated_organizations` array from the session is your source of truth for access control. ## When to use the hosted switcher instead [Section titled “When to use the hosted switcher instead”](#when-to-use-the-hosted-switcher-instead) The default Scalekit-hosted switcher is the right choice when: * You want the quickest implementation with minimal code * Your application doesn’t require in-app organization switching * You’re okay with users navigating through the authentication flow to switch organizations Build a custom switcher when user experience requirements demand deeper integration with your application’s UI and routing. You may refer to our [Sample Org Swithcer ](https://github.com/scalekit-inc/Nextjs-Django-Org-Switcher-Example/tree/main)application to better understand how the API calls enable this custom org switcher that is embedded inside your application. --- # DOCUMENT BOUNDARY --- # Build a multi-agent email triage crew with CrewAI > Use CrewAI multi-agent orchestration with Scalekit-authenticated Gmail tools to scan, classify, and draft replies to emails. CrewAI’s strength is multi-agent orchestration — you define specialized agents and let them collaborate on a shared workflow. But the moment those agents need to call Gmail, Slack, or GitHub on behalf of a real user, you’re stuck managing OAuth tokens, refresh cycles, and per-user credential storage before you write any agent logic. Scalekit eliminates that plumbing. It stores OAuth sessions per user, refreshes tokens automatically, and exposes authenticated tools over MCP. Your CrewAI code never touches a token — it connects to a Scalekit MCP URL and gets back ready-to-use tools. This cookbook builds a three-agent email triage crew: one agent scans unread emails, another classifies them by priority, and a third drafts replies for the high-priority items. All Gmail access goes through Scalekit. **What this recipe covers:** * **Scalekit MCP integration** — get a Virtual MCP Server URL and mint a session token that authenticates Gmail tools for a specific user * **CrewAI MCPServerAdapter** — connect CrewAI to the MCP server so agents can discover and call Gmail tools * **Multi-agent pipeline** — define three agents with distinct roles that run in sequence * **First-run authorization** — handle the OAuth flow when a user hasn’t connected Gmail yet The complete source is available in the [crewai-scalekit-example](https://github.com/scalekit-developers/crewai-scalekit-example) repository. ### 1. Set up Gmail and a Virtual MCP server [Section titled “1. Set up Gmail and a Virtual MCP server”](#1-set-up-gmail-and-a-virtual-mcp-server) New environments do not ship with a Virtual MCP server. Create the Gmail connection and the MCP config **before** you run the sample — otherwise `list_configs` returns an empty list. In the [Scalekit Dashboard](https://app.scalekit.com): 1. Go to **AgentKit** → **Connections** → **Create Connection** and select **Gmail**. 2. Note the **Connection name** — your code references it by this exact string (for example `gmail`). 3. Go to **AgentKit** → **MCP Configs** → **Create** and create a Virtual MCP config (for example `gmail-user-tools`). 4. Attach the Gmail connection and include the tools the crew needs (at least `gmail_fetch_mails`). 5. Copy the **config name** into `SCALEKIT_MCP_CONFIG_NAME` below. For the full API path (create config, mint session tokens, connect agents), see [Set up and connect a Virtual MCP server](/agentkit/mcp/configure-mcp-server/). ### 2. Install dependencies [Section titled “2. Install dependencies”](#2-install-dependencies) ```bash 1 pip install crewai crewai-tools scalekit-sdk-python python-dotenv ``` `crewai-tools` provides `MCPServerAdapter`, which connects CrewAI to any MCP server. `scalekit-sdk-python` generates the authenticated MCP URL for each user. ### 3. Configure credentials [Section titled “3. Configure credentials”](#3-configure-credentials) ```bash 1 cp .env.example .env ``` .env ```bash 1 # Scalekit — get these at app.scalekit.com → Settings → API Credentials 2 SCALEKIT_ENV_URL=https://your-env.scalekit.dev 3 SCALEKIT_CLIENT_ID=skc_... 4 SCALEKIT_CLIENT_SECRET=your-secret 5 6 # User identifier from your application 7 SCALEKIT_USER_IDENTIFIER=user_123 8 9 # Exact Connection name from AgentKit → Connections 10 GMAIL_CONNECTION_NAME=gmail 11 12 # MCP config name — must match the Virtual MCP config created in step 1 13 SCALEKIT_MCP_CONFIG_NAME=gmail-user-tools 14 15 # LLM — any OpenAI-compatible endpoint 16 OPENAI_API_KEY=sk-... ``` ### 4. Initialize Scalekit and ensure authorization [Section titled “4. Initialize Scalekit and ensure authorization”](#4-initialize-scalekit-and-ensure-authorization) ```python 1 import os 2 from scalekit import ScalekitClient 3 from dotenv import find_dotenv, load_dotenv 4 5 load_dotenv(find_dotenv()) 6 7 # Constructor: env_url, client_id, client_secret 8 scalekit_client = ScalekitClient( 9 os.environ["SCALEKIT_ENV_URL"], 10 os.environ["SCALEKIT_CLIENT_ID"], 11 os.environ["SCALEKIT_CLIENT_SECRET"], 12 ) 13 actions = scalekit_client.actions 14 15 USER_ID = os.getenv("SCALEKIT_USER_IDENTIFIER", "user_123") ``` Before calling any Gmail tool, check whether the user has an active connected account. If not, print an authorization link and wait for them to complete OAuth in the browser: ```python 1 # Use the exact Connection name from AgentKit → Connections (not a guessed slug). 2 CONNECTION_NAME = os.getenv("GMAIL_CONNECTION_NAME", "gmail") 3 4 response = actions.get_or_create_connected_account( 5 connection_name=CONNECTION_NAME, 6 identifier=USER_ID, 7 ) 8 connected_account = response.connected_account 9 10 # Do not start the crew until status is ACTIVE. 11 if connected_account.status != "ACTIVE": 12 link = actions.get_authorization_link( 13 connection_name=CONNECTION_NAME, 14 identifier=USER_ID, 15 ) 16 print(f"\n[{CONNECTION_NAME}] Authorization required.") 17 print(f"Open this link:\n\n {link.link}\n") 18 input("Press Enter after authorizing...") 19 response = actions.get_or_create_connected_account( 20 connection_name=CONNECTION_NAME, 21 identifier=USER_ID, 22 ) 23 connected_account = response.connected_account 24 25 if connected_account.status != "ACTIVE": 26 raise RuntimeError( 27 f"{CONNECTION_NAME} is still not ACTIVE. Complete authorization and try again." 28 ) ``` After the first successful authorization, `get_or_create_connected_account` returns an active account on all subsequent runs. Scalekit refreshes expired tokens automatically. ### 5. Connect to Gmail tools via MCP [Section titled “5. Connect to Gmail tools via MCP”](#5-connect-to-gmail-tools-via-mcp) Look up the Virtual MCP config you created in step 1, mint a session token, then pass both to `MCPServerAdapter`. If `list_configs` returns no results, stop and create the config first (dashboard or [configure-mcp-server](/agentkit/mcp/configure-mcp-server/)). Do not assume a default Virtual MCP server exists. ```python 1 from crewai_tools import MCPServerAdapter 2 from datetime import timedelta 3 4 mcp_config_name = os.getenv("SCALEKIT_MCP_CONFIG_NAME", "gmail-user-tools") 5 6 # Retrieve config_id by listing Virtual MCP Servers filtered by name 7 list_response = actions.mcp.list_configs(filter_name=mcp_config_name) 8 if not list_response.configs: 9 raise RuntimeError( 10 f"No Virtual MCP config named '{mcp_config_name}'. " 11 "Create one under AgentKit → MCP Configs (include Gmail tools), " 12 "or follow https://docs.scalekit.com/agentkit/mcp/configure-mcp-server/" 13 ) 14 15 mcp_server_url = list_response.configs[0].mcp_server_url 16 mcp_id = list_response.configs[0].id 17 18 token_response = actions.mcp.create_session_token( 19 mcp_config_id=mcp_id, 20 identifier=USER_ID, 21 expiry=timedelta(hours=1), 22 ) ``` Mint a fresh session token before each agent run. The Virtual MCP Server URL is static — it stays the same across all sessions. CrewAI’s `MCPServerAdapter` connects to the MCP server and discovers all available tools: ```python 1 with MCPServerAdapter({ 2 "url": mcp_server_url, 3 "headers": {"Authorization": f"Bearer {token_response.token}"}, 4 "transport": "streamable-http", 5 }) as tools: 6 # `tools` is a list of CrewAI-compatible tool objects 7 print(f"Discovered {len(tools)} Gmail tools") ``` ### 6. Define the agents [Section titled “6. Define the agents”](#6-define-the-agents) Three agents, each with a specific role. Only the Inbox Scanner needs direct access to Gmail tools — the other agents work with the data it produces: ```python 1 from crewai import Agent, LLM 2 3 llm = LLM( 4 model=os.getenv("LLM_MODEL", "gpt-4o"), 5 base_url=os.getenv("OPENAI_BASE_URL"), 6 api_key=os.getenv("OPENAI_API_KEY"), 7 ) 8 9 scanner = Agent( 10 role="Inbox Scanner", 11 goal="Fetch the user's latest unread emails and extract key metadata.", 12 backstory=( 13 "You are an efficient assistant that reads a Gmail inbox and " 14 "returns a structured summary of unread messages including " 15 "subject, sender, date, and a one-line preview." 16 ), 17 tools=tools, # Gmail tools from MCPServerAdapter 18 llm=llm, 19 verbose=True, 20 ) 21 22 prioritizer = Agent( 23 role="Email Prioritizer", 24 goal="Classify each email by urgency: high, medium, or low.", 25 backstory=( 26 "You are an expert at triaging incoming messages. You consider " 27 "sender importance, subject keywords, and time sensitivity to " 28 "assign a priority level to each email." 29 ), 30 llm=llm, 31 verbose=True, 32 ) 33 34 drafter = Agent( 35 role="Reply Drafter", 36 goal="Draft short, professional replies for high-priority emails.", 37 backstory=( 38 "You are a concise writer who drafts polite, on-point email " 39 "replies. You focus only on high-priority items and keep each " 40 "draft under 100 words." 41 ), 42 llm=llm, 43 verbose=True, 44 ) ``` ### 7. Define tasks and run the crew [Section titled “7. Define tasks and run the crew”](#7-define-tasks-and-run-the-crew) Each task describes what the agent should do and what output to expect. CrewAI runs them in sequence — each task receives the output of the previous one: ```python 1 from crewai import Crew, Process, Task 2 3 scan_task = Task( 4 description=( 5 "Fetch the last 5 unread emails from Gmail. For each email, " 6 "return: subject, sender name, sender email, date, and a " 7 "one-sentence preview of the body." 8 ), 9 expected_output=( 10 "A numbered list of 5 emails with subject, sender, date, " 11 "and preview for each." 12 ), 13 agent=scanner, 14 ) 15 16 prioritize_task = Task( 17 description=( 18 "Take the list of emails from the Inbox Scanner and classify " 19 "each one as high, medium, or low priority. Consider sender " 20 "importance, urgency cues in the subject, and whether the email " 21 "requires a response." 22 ), 23 expected_output=( 24 "The same list of emails, each now tagged with a priority " 25 "level (high / medium / low) and a brief reason." 26 ), 27 agent=prioritizer, 28 ) 29 30 draft_task = Task( 31 description=( 32 "For each email marked as high priority by the Prioritizer, " 33 "draft a short, professional reply (under 100 words). Skip " 34 "medium and low priority emails." 35 ), 36 expected_output=( 37 "A list of draft replies, one per high-priority email, " 38 "including the original subject line and the draft text." 39 ), 40 agent=drafter, 41 ) 42 43 crew = Crew( 44 agents=[scanner, prioritizer, drafter], 45 tasks=[scan_task, prioritize_task, draft_task], 46 process=Process.sequential, 47 verbose=True, 48 ) 49 50 result = crew.kickoff() 51 print(result) ``` ### 8. Run and test [Section titled “8. Run and test”](#8-run-and-test) ```bash 1 python agent.py ``` On first run, you see an authorization prompt: ```text 1 [gmail] Authorization required. 2 Open this link: 3 4 https://auth.scalekit.dev/connect/... 5 6 Press Enter after authorizing... ``` After completing OAuth in the browser and pressing Enter, the crew runs: ```text 1 [ok] Session token minted 2 Discovered 15 Gmail tools 3 4 [Inbox Scanner] Fetching unread emails... 5 [Email Prioritizer] Classifying 5 emails... 6 [Reply Drafter] Drafting replies for 2 high-priority emails... 7 8 ============================================================ 9 CREW RESULT 10 ============================================================ 11 ## High-Priority Emails — Draft Replies 12 13 1. Subject: "Q1 roadmap feedback needed" 14 From: Sarah Chen 15 Priority: HIGH 16 Draft: "Hi Sarah, thanks for flagging this. I'll review the 17 roadmap doc this afternoon and share my comments by EOD." 18 19 2. Subject: "Production incident — action required" 20 From: PagerDuty 21 Priority: HIGH 22 Draft: "Acknowledged. I'm looking into the alert now and will 23 update the incident channel within 15 minutes." ``` On subsequent runs, the authorization step is skipped entirely. ## Common mistakes [Section titled “Common mistakes”](#common-mistakes) ## Production notes [Section titled “Production notes”](#production-notes) **User ID from session** — The sample hardcodes `USER_ID = "user_123"`. In production, replace this with the real user identifier from your application’s session or JWT. A mismatch means Scalekit looks up the wrong user’s Gmail connection. **Token freshness** — Scalekit refreshes expired OAuth tokens before returning them. Mint a fresh session token before each agent run — session tokens are short-lived and scoped to a single run. **MCP server URL is static** — The Virtual MCP Server URL (`mcp_server_url`) is stable and the same for all users. Cache it once per config. Only the session token is per-run. **Rate limits** — Gmail API has per-user daily quotas. If your crew runs frequently, add rate-limiting logic or use Scalekit’s built-in tool pagination to limit the number of emails fetched per run. **Error handling** — In production, wrap `crew.kickoff()` in a try/except to handle LLM failures, MCP connection errors, and tool execution failures gracefully. Log the raw error for debugging. ## Next steps [Section titled “Next steps”](#next-steps) * **Add more connectors** — extend the crew with Slack, GitHub, or Calendar tools. Create additional connections in the dashboard, include them in your MCP config, and pass the expanded tool set to the Scanner agent. See [all supported connectors](/agentkit/connectors/). * **Try the AgentKit CrewAI example** — for a shorter, single-agent version of this pattern, see the [CrewAI example page](/agentkit/examples/crewai/). * **Explore other frameworks** — Scalekit works with LangChain, Google ADK, Vercel AI SDK, and more. See [AgentKit code samples](/agentkit/examples/) for the full list. * **Handle re-authorization** — if a user revokes Gmail access, `get_or_create_connected_account` returns an inactive account. Add a re-authorization path to recover gracefully. * **Review the AgentKit quickstart** — for a broader overview of connections, tools, and MCP, see the [AgentKit quickstart](/agentkit/quickstart/). --- # DOCUMENT BOUNDARY --- # Build a daily briefing agent with Vercel AI SDK and Scalekit Agent Auth > Connect a TypeScript or Python agent via Vercel AI SDK and Scalekit AgentKit to Google Calendar and Gmail with authenticated tool calls. A daily briefing agent needs two things: today’s calendar events and the latest unread emails. Both live behind OAuth-protected APIs, and each requires its own token, its own authorization flow, and its own refresh logic. Before you write any scheduling logic, you’re already maintaining two parallel token lifecycles. Scalekit eliminates that overhead. It stores one OAuth session per connector per user, refreshes tokens automatically, and exposes **built-in tools** such as `googlecalendar_list_events` and `gmail_fetch_mails`. Your agent calls those tools through Scalekit; it never talks to the Google Calendar or Gmail REST APIs directly. **What this recipe covers:** * **Authorize once per connector** — create connected accounts for Calendar and Gmail, open the OAuth link if needed, and wait until status is `ACTIVE` * **Built-in tool calls** — `execute_tool("googlecalendar_list_events")` and `execute_tool("gmail_fetch_mails")` so Scalekit runs the provider call and returns structured data * **Wire both tools into an agent** — Vercel AI SDK (TypeScript) or Anthropic messages (Python) The complete source used here is available in the [vercel-ai-agent-toolkit](https://github.com/scalekit-developers/vercel-ai-agent-toolkit) repository, with a TypeScript implementation using the Vercel AI SDK and a Python implementation using the Anthropic SDK directly. ### 1. Set up connections in Scalekit [Section titled “1. Set up connections in Scalekit”](#1-set-up-connections-in-scalekit) In the [Scalekit Dashboard](https://app.scalekit.com), create two connections under **AgentKit** > **Connections** > **Create Connection**: * `googlecalendar` — Google Calendar OAuth connection * `gmail` — Gmail OAuth connection The connection names are identifiers your code references directly. They must match exactly. ### 2. Install dependencies [Section titled “2. Install dependencies”](#2-install-dependencies) * TypeScript ```bash 1 cd typescript 2 pnpm install ``` The `typescript/package.json` includes: ```json 1 { 2 "dependencies": { 3 "ai": "^4.3.15", 4 "@ai-sdk/anthropic": "^1.2.12", 5 "@scalekit-sdk/node": "2.2.0-beta.1", 6 "zod": "^3.0.0", 7 "dotenv": "^16.0.0" 8 } 9 } ``` * Python ```bash 1 cd python 2 uv venv .venv 3 uv pip install -r requirements.txt ``` The `python/requirements.txt` includes: ```text 1 scalekit-sdk-python 2 anthropic 3 python-dotenv ``` ### 3. Configure credentials [Section titled “3. Configure credentials”](#3-configure-credentials) Copy the example env file and fill in your credentials: ```bash 1 cp typescript/.env.example typescript/.env # TypeScript 2 cp typescript/.env.example python/.env # Python (same variables) ``` .env ```bash 1 SCALEKIT_ENV_URL=https://your-env.scalekit.dev 2 SCALEKIT_CLIENT_ID=skc_... 3 SCALEKIT_CLIENT_SECRET=your-secret 4 5 ANTHROPIC_API_KEY=sk-ant-... ``` Get your Scalekit credentials at **app.scalekit.com → Settings → API Credentials**. ### 4. Initialize the Scalekit client [Section titled “4. Initialize the Scalekit client”](#4-initialize-the-scalekit-client) * TypeScript ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node'; 2 import { ConnectorStatus } from '@scalekit-sdk/node/lib/pkg/grpc/scalekit/v1/connected_accounts/connected_accounts_pb.js'; 3 import 'dotenv/config'; 4 5 // Never hard-code credentials — they would be exposed in source control. 6 // Pull them from environment variables at runtime. 7 const scalekit = new ScalekitClient( 8 process.env.SCALEKIT_ENV_URL!, 9 process.env.SCALEKIT_CLIENT_ID!, 10 process.env.SCALEKIT_CLIENT_SECRET!, 11 ); 12 const actions = scalekit.actions; 13 14 const USER_ID = 'user_123'; // Replace with the real user ID from your session ``` `ConnectorStatus` is imported from the SDK’s generated protobuf file. Compare `connectedAccount.status` against `ConnectorStatus.ACTIVE` rather than the string `'ACTIVE'` — TypeScript’s type system enforces this. * Python ```python 1 import os 2 import json 3 from datetime import datetime 4 from dotenv import load_dotenv 5 import anthropic 6 from scalekit import ScalekitClient 7 8 load_dotenv() 9 10 # Never hard-code credentials — they would be exposed in source control. 11 # Pull them from environment variables at runtime. 12 # Constructor: env_url, client_id, client_secret 13 scalekit_client = ScalekitClient( 14 os.environ["SCALEKIT_ENV_URL"], 15 os.environ["SCALEKIT_CLIENT_ID"], 16 os.environ["SCALEKIT_CLIENT_SECRET"], 17 ) 18 actions = scalekit_client.actions 19 20 USER_ID = "user_123" # Replace with the real user ID from your session ``` `scalekit_client.actions` is the entry point for connected-account operations and built-in tool execution. ### 5. Ensure each connector is authorized [Section titled “5. Ensure each connector is authorized”](#5-ensure-each-connector-is-authorized) Before calling any API, check whether the user has an active connected account. If not, print an authorization link and wait for them to complete the browser OAuth flow. * TypeScript ```typescript 1 async function ensureConnected(connectionName: string) { 2 let { connectedAccount } = await actions.getOrCreateConnectedAccount({ 3 connectionName, 4 identifier: USER_ID, 5 }); 6 7 // Do not call tools until the user finishes OAuth and status is ACTIVE. 8 if (connectedAccount?.status !== ConnectorStatus.ACTIVE) { 9 const { link } = await actions.getAuthorizationLink({ 10 connectionName, 11 identifier: USER_ID, 12 }); 13 console.log(`\n[${connectionName}] Authorization required.`); 14 console.log(`Open this link:\n\n ${link}\n`); 15 console.log('Press Enter once you have completed the OAuth flow...'); 16 await new Promise(resolve => { 17 process.stdin.resume(); 18 process.stdin.once('data', () => { process.stdin.pause(); resolve(); }); 19 }); 20 21 const refreshed = await actions.getOrCreateConnectedAccount({ 22 connectionName, 23 identifier: USER_ID, 24 }); 25 connectedAccount = refreshed.connectedAccount; 26 } 27 28 if (connectedAccount?.status !== ConnectorStatus.ACTIVE) { 29 throw new Error(`${connectionName} is still not ACTIVE. Complete authorization and try again.`); 30 } 31 32 return connectedAccount; 33 } ``` * Python ```python 1 def ensure_connected(connection_name: str): 2 response = actions.get_or_create_connected_account( 3 connection_name=connection_name, 4 identifier=USER_ID, 5 ) 6 connected_account = response.connected_account 7 8 # Do not call tools until the user finishes OAuth and status is ACTIVE. 9 if connected_account.status != "ACTIVE": 10 link_response = actions.get_authorization_link( 11 connection_name=connection_name, 12 identifier=USER_ID, 13 ) 14 print(f"\n[{connection_name}] Authorization required.") 15 print(f"Open this link:\n\n {link_response.link}\n") 16 input("Press Enter once you have completed the OAuth flow...") 17 response = actions.get_or_create_connected_account( 18 connection_name=connection_name, 19 identifier=USER_ID, 20 ) 21 connected_account = response.connected_account 22 23 if connected_account.status != "ACTIVE": 24 raise RuntimeError( 25 f"{connection_name} is still not ACTIVE. Complete authorization and try again." 26 ) 27 28 return connected_account ``` After the first successful authorization, `getOrCreateConnectedAccount` / `get_or_create_connected_account` returns an active account on all subsequent calls. Scalekit refreshes expired tokens automatically — your code never calls a token-refresh endpoint. ### 6. Fetch calendar events with a built-in tool [Section titled “6. Fetch calendar events with a built-in tool”](#6-fetch-calendar-events-with-a-built-in-tool) Call `execute_tool` with `googlecalendar_list_events`. Scalekit uses the stored OAuth session, calls Google Calendar, and returns structured event data. Your agent never handles a Google access token or the Calendar REST API. * TypeScript ```typescript 1 import { tool } from 'ai'; 2 import { z } from 'zod'; 3 4 const getCalendarEvents = tool({ 5 description: "Fetch today's events from Google Calendar via Scalekit", 6 parameters: z.object({ 7 maxResults: z.number().optional().default(5), 8 }), 9 execute: async ({ maxResults }) => { 10 const response = await actions.executeTool({ 11 toolName: 'googlecalendar_list_events', 12 connectedAccountId: calendarAccount?.id, 13 toolInput: { 14 max_results: maxResults, 15 }, 16 }); 17 // Tool output lives under data — log once when integrating a new tool. 18 return response.data ?? {}; 19 }, 20 }); ``` * Python ```python 1 def fetch_calendar_events(connected_account_id: str, max_results: int = 5) -> dict: 2 response = actions.execute_tool( 3 tool_name="googlecalendar_list_events", 4 connected_account_id=connected_account_id, 5 tool_input={ 6 "max_results": max_results, 7 }, 8 ) 9 # Tool output lives under data — log once when integrating a new tool. 10 return response.data ``` ### 7. Fetch emails with a built-in tool [Section titled “7. Fetch emails with a built-in tool”](#7-fetch-emails-with-a-built-in-tool) Use the same `execute_tool` pattern for Gmail with `gmail_fetch_mails`. Scalekit runs the Gmail API call and returns structured data. * TypeScript ```typescript 1 const getUnreadEmails = tool({ 2 description: 'Fetch top unread emails from Gmail via Scalekit actions', 3 parameters: z.object({ 4 maxResults: z.number().optional().default(5), 5 }), 6 execute: async ({ maxResults }) => { 7 const response = await actions.executeTool({ 8 toolName: 'gmail_fetch_mails', 9 connectedAccountId: gmailAccount?.id, 10 toolInput: { 11 query: 'is:unread', 12 max_results: maxResults, 13 }, 14 }); 15 return response.data ?? {}; 16 }, 17 }); ``` * Python ```python 1 def fetch_unread_emails(connected_account_id: str, max_results: int = 5) -> dict: 2 response = actions.execute_tool( 3 tool_name="gmail_fetch_mails", 4 connected_account_id=connected_account_id, 5 tool_input={ 6 "query": "is:unread", 7 "max_results": max_results, 8 }, 9 ) 10 return response.data ``` You do not need Google Calendar or Gmail API docs for the common path — tool names and parameters are consistent across Scalekit connectors. Browse [all supported agent connectors](/agentkit/connectors/) for the full tool list. ### 8. Wire the agent together [Section titled “8. Wire the agent together”](#8-wire-the-agent-together) Pass both tools to the LLM and ask for a daily summary. * TypeScript The TypeScript version uses the Vercel AI SDK’s `generateText` with `maxSteps` to allow the LLM to call multiple tools in sequence before producing the final response. ```typescript 1 import { generateText } from 'ai'; 2 import { anthropic } from '@ai-sdk/anthropic'; 3 4 const [calendarAccount, gmailAccount] = await Promise.all([ 5 ensureConnected('googlecalendar'), 6 ensureConnected('gmail'), 7 ]); 8 9 const today = new Date(); 10 11 const { text } = await generateText({ 12 model: anthropic('claude-sonnet-4-6'), 13 prompt: `Give me a summary of my day for ${today.toDateString()}: list today's calendar events and my top 5 unread emails.`, 14 tools: { 15 getCalendarEvents, 16 getUnreadEmails, 17 }, 18 maxSteps: 5, // allow the LLM to call multiple tools before responding 19 }); 20 21 console.log(text); ``` `maxSteps` controls how many tool-call rounds the LLM can make before it must return a final text response. Without it, `generateText` stops after the first tool call. * Python The Python version uses the Anthropic SDK directly with a manual agentic loop. The loop continues until the model returns `stop_reason == "end_turn"` with no pending tool calls. ```python 1 def run_agent(): 2 calendar_account = ensure_connected("googlecalendar") 3 gmail_account = ensure_connected("gmail") 4 5 client = anthropic.Anthropic() 6 today = datetime.now().strftime("%A, %B %d, %Y") 7 8 tools = [ 9 { 10 "name": "get_calendar_events", 11 "description": "Fetch today's events from Google Calendar via Scalekit", 12 "input_schema": { 13 "type": "object", 14 "properties": {"max_results": {"type": "integer", "default": 5}}, 15 }, 16 }, 17 { 18 "name": "get_unread_emails", 19 "description": "Fetch top unread emails from Gmail via Scalekit actions", 20 "input_schema": { 21 "type": "object", 22 "properties": {"max_results": {"type": "integer", "default": 5}}, 23 }, 24 }, 25 ] 26 27 messages = [ 28 { 29 "role": "user", 30 "content": f"Give me a summary of my day for {today}: list today's calendar events and my top 5 unread emails.", 31 } 32 ] 33 34 while True: 35 response = client.messages.create( 36 model="claude-sonnet-4-6", 37 max_tokens=1024, 38 tools=tools, 39 messages=messages, 40 ) 41 messages.append({"role": "assistant", "content": response.content}) 42 43 if response.stop_reason == "end_turn": 44 for block in response.content: 45 if hasattr(block, "text"): 46 print(block.text) 47 break 48 49 tool_results = [] 50 for block in response.content: 51 if block.type == "tool_use": 52 max_results = block.input.get("max_results", 5) 53 if block.name == "get_calendar_events": 54 result = fetch_calendar_events(calendar_account.id, max_results) 55 elif block.name == "get_unread_emails": 56 result = fetch_unread_emails(gmail_account.id, max_results) 57 else: 58 result = {"error": f"Unknown tool: {block.name}"} 59 tool_results.append({ 60 "type": "tool_result", 61 "tool_use_id": block.id, 62 "content": json.dumps(result), 63 }) 64 65 if tool_results: 66 messages.append({"role": "user", "content": tool_results}) 67 else: 68 break 69 70 if __name__ == "__main__": 71 run_agent() ``` ### 9. Testing [Section titled “9. Testing”](#9-testing) Run the agent: * TypeScript ```bash 1 cd typescript && pnpm start ``` * Python ```bash 1 cd python && .venv/bin/python index.py ``` On first run, you see two authorization prompts in sequence: ```text 1 [googlecalendar] Authorization required. 2 Open this link: 3 4 https://auth.scalekit.dev/connect/... 5 6 Press Enter once you have completed the OAuth flow... 7 8 [gmail] Authorization required. 9 Open this link: 10 11 https://auth.scalekit.dev/connect/... 12 13 Press Enter once you have completed the OAuth flow... ``` After both connectors are authorized, the agent fetches your data and returns a summary: ```text 1 Here's your day for Friday, March 27, 2026: 2 3 📅 Calendar — 3 events today 4 • 9:00 AM Team standup (30 min) 5 • 1:00 PM Product review 6 • 4:00 PM 1:1 with manager 7 8 📧 Unread emails — top 5 9 • "Q1 roadmap feedback needed" — Sarah Chen, 1h ago 10 • "Deploy failed: production" — GitHub Actions, 2h ago 11 • "New PR review requested" — Lin Feng, 3h ago 12 ... ``` On subsequent runs, both authorization prompts are skipped. Scalekit returns the active session directly. ## Common mistakes [Section titled “Common mistakes”](#common-mistakes) ## Production notes [Section titled “Production notes”](#production-notes) **User ID from session** — Both implementations hardcode `USER_ID = "user_123"`. In production, replace this with the real user identifier from your application’s session. A mismatch means Scalekit looks up the wrong user’s connected accounts. **Token freshness** — Scalekit refreshes OAuth tokens automatically before tool execution. You do not fetch provider tokens or call a refresh endpoint in application code. **First-run blocking** — The authorization prompt blocks the process until the user completes OAuth in the browser. In a web application, redirect the user to `link` instead of printing it, and handle the callback before proceeding. **`execute_tool` response shape** — Tool output lives under `response.data` (Python and Node). Keys inside `data` depend on the tool. Log the raw response once when integrating a new tool, then pass that structure to the LLM. **Rate limits** — Google Calendar and Gmail both enforce per-user quotas. If your agent runs frequently, avoid tight polling loops and cache briefing data where freshness allows. ## Next steps [Section titled “Next steps”](#next-steps) * **Add more connectors** — The same `ensureConnected` + `execute_tool` pattern works for any Scalekit-supported connector. Swap the connection name and tool name. See [all supported connectors](/agentkit/connectors/). * **Need a raw provider call** — Prefer built-in tools first. If a tool does not cover your case, see [proxy API calls](/agentkit/advanced/proxy-api-calls/) rather than extracting tokens in app code. * **Stream the response** — Replace `generateText` with `streamText` in the Vercel AI SDK to stream the LLM’s summary token-by-token instead of waiting for the full response. * **Handle re-authorization** — If a user revokes access, `getOrCreateConnectedAccount` returns an inactive account. Add a re-authorization path to recover gracefully instead of crashing. * **Review the agent auth quickstart** — For a broader overview of the connected-accounts model and supported providers, see the [agent auth quickstart](/agentkit/quickstart/). --- # DOCUMENT BOUNDARY --- # FastRouter + Scalekit tool calling > Build a Node.js agent that routes LLM calls through FastRouter and uses Scalekit for per-user OAuth tools. Build an agent that routes LLM calls through [FastRouter](https://fastrouter.ai). FastRouter provides an OpenAI-compatible chat completions API, so the integration requires only one configuration change: point the OpenAI SDK’s `baseURL` at FastRouter. Scalekit extends that with per-user OAuth tool access, so your agent can read Gmail, create GitHub issues, or post to Slack on behalf of individual users. You can choose from [200+ connectors](/agentkit/connectors/). Scalekit handles OAuth token storage, tool discovery, and tool execution for every connected service. The sample repository is **[fastrouter-scalekit-demo](https://github.com/scalekit-developers/fastrouter-scalekit-demo)** on GitHub. ## What you are building [Section titled “What you are building”](#what-you-are-building) * **FastRouter as the LLM provider** — All chat completions go through FastRouter’s OpenAI-compatible endpoint. Switch models by changing one environment variable. * **Scalekit for tool access** — `listScopedTools` returns per-user tool schemas ready to pass directly to FastRouter. `executeTool` runs each tool server-side and returns structured results. * **B2B OAuth without custom OAuth code** — Scalekit handles the OAuth flow, token storage, and refresh for each connected service. Your agent gets an auth link, waits for the user to authorize, and receives a verified, active connected account. * **Agentic loop** — The agent calls FastRouter, receives tool calls, executes them through Scalekit, and feeds results back — repeating until FastRouter returns a final answer. ## Prerequisites [Section titled “Prerequisites”](#prerequisites) * Scalekit account with AgentKit enabled — [create one at app.scalekit.com](https://app.scalekit.com) * At least one AgentKit connection configured (Gmail, GitHub, or Slack) * FastRouter account and API key — [sign up at fastrouter.ai](https://fastrouter.ai) * Node.js 20 or later * For Python code examples: `pip install google-protobuf` (required for tool schema deserialization) ## Clone and run the sample [Section titled “Clone and run the sample”](#clone-and-run-the-sample) 1. **Clone the repository and install dependencies.** ```sh 1 git clone https://github.com/scalekit-developers/fastrouter-scalekit-demo 2 cd fastrouter-scalekit-demo 3 npm install ``` 2. **Copy the example environment file and fill in your credentials.** ```sh 1 cp .env.example .env ``` Open `.env` and set these values: ```sh 1 # Scalekit — find these in your Scalekit dashboard under API Keys 2 SCALEKIT_ENV_URL=https://your-env.scalekit.dev 3 SCALEKIT_CLIENT_ID=your_client_id 4 SCALEKIT_CLIENT_SECRET=your_client_secret 5 6 # The AgentKit connection to use — must match a connection name in your dashboard 7 SCALEKIT_CONNECTION_NAME=gmail 8 9 # FastRouter — find your API key at fastrouter.ai/dashboard 10 FASTROUTER_API_KEY=sk-v1-... 11 FASTROUTER_MODEL=openai/gpt-4o-mini ``` `SCALEKIT_CONNECTION_NAME` must match the exact connection name in your Scalekit dashboard under **AgentKit → Connections**. 3. **Run the agent.** ```sh 1 npm start ``` 4. **Authorize the connection on first run.** The agent prints an authorization link if the connected account is not yet active: ```plaintext 1 Authorization required. 2 Open this link and complete the flow: 3 4 https://your-env.scalekit.dev/magicLink/... 5 6 Waiting for callback on http://localhost:3000/callback ... ``` Open the link in your browser and complete the OAuth flow. The agent detects the callback automatically and continues — no manual step required. After authorization, the agent loads tools, calls FastRouter, and prints a final answer: ```plaintext 1 Connected account is now active. 2 Loaded 17 scoped tools from Scalekit. 3 Model requested 1 tool call(s). 4 5 → Executing gmail_list_messages 6 args: {"maxResults":5,"q":"is:unread"} 7 8 Final answer: 9 10 Here are your 5 most recent unread emails: ... ``` ## How the agent works [Section titled “How the agent works”](#how-the-agent-works) Three pieces connect FastRouter to Scalekit tools. ### B2B OAuth connects user accounts without custom token code [Section titled “B2B OAuth connects user accounts without custom token code”](#b2b-oauth-connects-user-accounts-without-custom-token-code) Scalekit handles the full OAuth flow. Your agent calls `getOrCreateConnectedAccount` to check whether the user’s account is already connected, then calls `getAuthorizationLink` to get an auth URL if it isn’t. * Node.js ```typescript 1 import { ConnectorStatus } from '@scalekit-sdk/node/lib/pkg/grpc/scalekit/v1/connected_accounts/connected_accounts_pb'; 2 import crypto from 'node:crypto'; 3 4 const connectionName = process.env.SCALEKIT_CONNECTION_NAME; 5 if (!connectionName) { 6 throw new Error('SCALEKIT_CONNECTION_NAME is required'); 7 } 8 9 const userVerifyUrl = 'http://localhost:3000/callback'; 10 11 // Generate a random state value and store it (e.g. in a secure cookie or session) 12 // to validate on the OAuth callback and prevent CSRF / account mix-up attacks. 13 const state = crypto.randomUUID(); 14 15 const { connectedAccount } = await scalekit.actions.getOrCreateConnectedAccount({ 16 connectionName, 17 identifier: 'user_123', 18 userVerifyUrl, 19 }); 20 21 if (connectedAccount?.status !== ConnectorStatus.ACTIVE) { 22 const { link } = await scalekit.actions.getAuthorizationLink({ 23 connectionName, 24 identifier: 'user_123', 25 userVerifyUrl, 26 state, 27 }); 28 // Show link to user, then wait for the browser redirect callback 29 } ``` * Python ```python 1 import os 2 import secrets 3 4 connection_name = os.environ["SCALEKIT_CONNECTION_NAME"] 5 user_verify_url = "http://localhost:3000/callback" 6 7 # Generate and store a state value (e.g. in a secure, HTTP-only cookie) for CSRF protection 8 state = secrets.token_urlsafe(32) 9 10 response = scalekit_client.actions.get_or_create_connected_account( 11 connection_name=connection_name, 12 identifier="user_123", 13 user_verify_url=user_verify_url, 14 ) 15 16 if response.connected_account.status != "ACTIVE": 17 link_resp = scalekit_client.actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier="user_123", 20 user_verify_url=user_verify_url, 21 state=state, 22 ) 23 # Show link_resp.link to the user ``` `userVerifyUrl` is where Scalekit redirects the user’s browser after the OAuth flow completes (GET request with `auth_request_id` and `state` query parameters). The sample runs a minimal HTTP server on `localhost:3000` to catch that redirect, validate the `state` against the original value, extract the `auth_request_id`, and call `verifyConnectedAccountUser` to mark the account active: * Node.js ```typescript 1 async function waitForCallback(port: number, expectedState: string): Promise { 2 return new Promise((resolve, reject) => { 3 const server = http.createServer((req, res) => { 4 const url = new URL(req.url ?? '/', `http://localhost:${port}`); 5 const authRequestId = url.searchParams.get('auth_request_id'); 6 const returnedState = url.searchParams.get('state'); 7 8 res.writeHead(200, { 'Content-Type': 'text/html' }); 9 res.end('

Authorization complete — return to your terminal.

'); 10 server.close(); 11 12 if (authRequestId && returnedState === expectedState) { 13 resolve(authRequestId); 14 } else { 15 reject(new Error('Invalid or missing auth_request_id or state in callback')); 16 } 17 }); 18 server.listen(port); 19 }); 20 } 21 22 const authRequestId = await waitForCallback(3000, state); 23 await scalekit.actions.verifyConnectedAccountUser({ 24 authRequestId, 25 identifier: 'user_123', 26 }); ``` * Python ```python 1 # In your web framework callback handler (e.g. FastAPI): 2 # 1. Validate that the "state" query param matches the value you stored earlier 3 # 2. Then exchange the auth_request_id (never trust identity from the URL alone) 4 5 result = scalekit_client.actions.verify_connected_account_user( 6 auth_request_id=auth_request_id, 7 identifier="user_123", 8 ) 9 # redirect to result.post_user_verify_redirect_url ``` ### Tool discovery returns schemas in FastRouter’s expected format [Section titled “Tool discovery returns schemas in FastRouter’s expected format”](#tool-discovery-returns-schemas-in-fastrouters-expected-format) `listScopedTools` returns only the tools the connected account has permission to use. Map each tool’s `input_schema` to the `parameters` field FastRouter expects: ```typescript 1 const { tools } = await scalekit.tools.listScopedTools('user_123', { 2 filter: { connectionNames: [connectionName] }, 3 pageSize: 100, 4 }); 5 6 const fastRouterTools = tools 7 .map((t) => t.tool?.definition) 8 .filter((def): def is NonNullable => Boolean(def?.name)) 9 .map((def) => ({ 10 type: 'function' as const, 11 function: { 12 name: String(def.name), 13 description: String(def.description ?? ''), 14 parameters: def.input_schema ?? { type: 'object', properties: {} }, 15 }, 16 })); ``` FastRouter uses the same function-calling format as OpenAI. No additional schema transformation is needed. ### The agentic loop runs until the model stops requesting tools [Section titled “The agentic loop runs until the model stops requesting tools”](#the-agentic-loop-runs-until-the-model-stops-requesting-tools) Pass the tool list to FastRouter and execute each tool call through Scalekit until the model returns a response with no tool calls: ```typescript 1 const messages: OpenAI.ChatCompletionMessageParam[] = [ 2 { role: 'system', content: 'You are a helpful assistant. Use tools when they help. Do not invent tool results.' }, 3 { role: 'user', content: 'Fetch my last 5 unread emails and summarize them.' }, 4 ]; 5 6 for (let turn = 0; turn < 8; turn++) { 7 const response = await fastRouter.chat.completions.create({ 8 model: 'openai/gpt-4o-mini', 9 messages, 10 tools: fastRouterTools, 11 tool_choice: 'auto', 12 }); 13 14 const message = response.choices[0].message; 15 messages.push(message); 16 17 // No tool calls means a final answer 18 if (!message.tool_calls?.length) { 19 console.log(message.content); 20 return; 21 } 22 23 // Execute each tool call and append the result 24 for (const call of message.tool_calls) { 25 const result = await scalekit.actions.executeTool({ 26 toolName: call.function.name, 27 identifier: 'user_123', 28 connector: connectionName, 29 toolInput: JSON.parse(call.function.arguments), 30 }); 31 32 messages.push({ 33 role: 'tool', 34 tool_call_id: call.id, 35 content: JSON.stringify(result.data ?? {}), 36 }); 37 } 38 } ``` `executeTool` runs the tool server-side using the connected account’s stored OAuth tokens. Your agent never handles raw access tokens. ## Customize the agent [Section titled “Customize the agent”](#customize-the-agent) **Change the connection.** Set `SCALEKIT_CONNECTION_NAME` to any connection configured in your Scalekit dashboard: | Value | What it connects | | -------- | ----------------------------------- | | `gmail` | Gmail read/send | | `github` | Repositories, issues, pull requests | | `slack` | Channels, messages, users | **Change the model.** Set `FASTROUTER_MODEL` in `.env` to any model FastRouter supports. The agent uses the same code regardless of which model you choose. **Change the prompt.** Pass a prompt as a CLI argument to override the default: ```sh 1 npm start "List all GitHub pull requests assigned to me" ``` Or set `USER_PROMPT` in `.env` to change the default. **Support multiple connections.** Call `listScopedTools` with multiple connection names to give the model tools from all of them at once: ```typescript 1 const { tools } = await scalekit.tools.listScopedTools('user_123', { 2 filter: { connectionNames: ['gmail', 'github', 'slack'] }, 3 }); ``` ## Next steps [Section titled “Next steps”](#next-steps) * **[Scalekit overview](/agentkit/connections)** — Understand connected accounts, tool discovery, and tool execution in depth. * **[AgentKit connections](/agentkit/connectors)** — Set up Gmail, GitHub, Slack, and other connections. * **[OpenAI example](/agentkit/examples/openai)** — See the same tool-calling pattern with OpenAI directly. * **[LiteLLM inbox triage cookbook](/cookbooks/litellm-agentkit-inbox-triage)** — A more complex multi-connection agent with a web approval interface. --- # DOCUMENT BOUNDARY --- # Implement passwordless auth in Next.js 15 > Add magic link and OTP authentication to your Next.js application using Scalekit's headless API. Next.js 15’s App Router expects authentication to be server-first: tokens generated on the server, verification happening in Route Handlers or Server Actions, and sessions stored in HttpOnly cookies. If you’re building passwordless authentication (magic links + OTP), traditional client-side SDKs won’t work properly with this model. This cookbook shows you how to implement passwordless auth that works natively with Next.js 15’s architecture using Scalekit’s headless API. ## The problem [Section titled “The problem”](#the-problem) You want passwordless authentication in Next.js 15 but face these challenges: * **Client-side SDKs break App Router patterns** - They expect browser-side token handling, which violates server-first principles * **Vendor UIs don’t match your design** - Pre-built login pages force you to compromise on branding * **DIY is complex** - Building secure token generation, email delivery, verification, and session management from scratch is a significant lift * **Cross-device failures** - Magic links often break when users switch devices or email clients strip parameters ## Who needs this [Section titled “Who needs this”](#who-needs-this) This cookbook is for you if: * ✅ You’re building a Next.js 15 application using App Router * ✅ You want passwordless authentication (magic links, OTP, or both) * ✅ You need full control over your login UI and email design * ✅ You don’t want to migrate your existing user database * ✅ You require server-side security for compliance You **don’t** need this if: * ❌ You’re happy with vendor-hosted login pages * ❌ You’re using Next.js Pages Router (not App Router) * ❌ You prefer traditional username/password authentication ## The solution [Section titled “The solution”](#the-solution) Scalekit’s passwordless API provides three server-side methods that integrate directly with Next.js 15’s architecture: 1. **`sendPasswordlessEmail()`** - Generates and sends magic link/OTP to user’s email 2. **`verifyPasswordlessEmail()`** - Validates the token/code and returns verified identity 3. **`resendPasswordlessEmail()`** - Issues a fresh credential if the first expires All security logic stays server-side, works with Server Actions and Route Handlers, and integrates with Edge Middleware for route protection. ## Implementation [Section titled “Implementation”](#implementation) ### 1. Configure Scalekit dashboard [Section titled “1. Configure Scalekit dashboard”](#1-configure-scalekit-dashboard) Enable passwordless authentication in your [Scalekit dashboard](https://app.scalekit.com/): 1. Navigate to **Authentication → Passwordless** 2. Select **Magic Link + Verification Code** for maximum reliability 3. Set **Expiry Period** (e.g., 600 seconds for 10-minute lifetime) 4. Enable **Enforce same browser origin** to prevent link hijacking 5. (Optional) Enable **Regenerate credentials on resend** to invalidate old links ### 2. Install dependencies and configure environment [Section titled “2. Install dependencies and configure environment”](#2-install-dependencies-and-configure-environment) ```bash 1 npm install @scalekit-sdk/node jsonwebtoken ``` Create `.env.local`: ```bash 1 SCALEKIT_ENVIRONMENT_URL=env_xxxx 2 SCALEKIT_CLIENT_ID=skc_xxx 3 SCALEKIT_CLIENT_SECRET=your_secret 4 APP_URL=http://localhost:3000 5 JWT_SECRET=your_jwt_secret ``` ### 3. Create session management utilities [Section titled “3. Create session management utilities”](#3-create-session-management-utilities) Create `lib/session-store.ts` to handle server-side session creation: ```typescript 1 import jwt from 'jsonwebtoken'; 2 import { cookies } from 'next/headers'; 3 4 const COOKIE = 'session'; 5 const SECRET = process.env.JWT_SECRET!; 6 7 export function createSession(email: string) { 8 const token = jwt.sign({ email }, SECRET, { expiresIn: '7d' }); 9 cookies().set(COOKIE, token, { 10 httpOnly: true, 11 secure: process.env.NODE_ENV === 'production', 12 sameSite: 'lax', 13 path: '/', 14 maxAge: 60 * 60 * 24 * 7, 15 }); 16 } 17 18 export function readSessionEmail(): string | null { 19 const token = cookies().get(COOKIE)?.value; 20 if (!token) return null; 21 22 try { 23 const decoded = jwt.verify(token, SECRET) as { email: string }; 24 return decoded.email; 25 } catch { 26 return null; 27 } 28 } 29 30 export function clearSession() { 31 cookies().delete(COOKIE); 32 } ``` ### 4. Create send email endpoint [Section titled “4. Create send email endpoint”](#4-create-send-email-endpoint) Create `app/api/auth/send-passwordless/route.ts`: ```typescript 1 import Scalekit from '@scalekit-sdk/node'; 2 import { NextRequest, NextResponse } from 'next/server'; 3 4 const scalekit = new Scalekit( 5 process.env.SCALEKIT_ENVIRONMENT_URL!, 6 process.env.SCALEKIT_CLIENT_ID!, 7 process.env.SCALEKIT_CLIENT_SECRET! 8 ); 9 10 export async function POST(req: NextRequest) { 11 const { email } = await req.json(); 12 13 try { 14 const response = await scalekit.passwordless.sendPasswordlessEmail(email, { 15 template: 'SIGNIN', 16 expiresIn: 600, // 10 minutes 17 state: crypto.randomUUID(), 18 magiclinkAuthUri: `${process.env.APP_URL}/api/auth/verify`, 19 }); 20 21 return NextResponse.json({ 22 authRequestId: response.authRequestId, 23 expiresAt: response.expiresAt, 24 }); 25 } catch (error) { 26 return NextResponse.json( 27 { error: 'Failed to send email' }, 28 { status: 500 } 29 ); 30 } 31 } ``` ### 5. Create verification endpoint [Section titled “5. Create verification endpoint”](#5-create-verification-endpoint) Create `app/api/auth/verify/route.ts` with both GET (magic link) and POST (OTP) handlers: ```typescript 1 import Scalekit from '@scalekit-sdk/node'; 2 import { NextRequest, NextResponse } from 'next/server'; 3 import { createSession } from '@/lib/session-store'; 4 5 const scalekit = new Scalekit( 6 process.env.SCALEKIT_ENVIRONMENT_URL!, 7 process.env.SCALEKIT_CLIENT_ID!, 8 process.env.SCALEKIT_CLIENT_SECRET! 9 ); 10 11 // Magic link verification 12 export async function GET(req: NextRequest) { 13 const url = new URL(req.url); 14 const linkToken = url.searchParams.get('link_token'); 15 const authRequestId = url.searchParams.get('auth_request_id') ?? undefined; 16 17 if (!linkToken) { 18 return NextResponse.redirect( 19 new URL('/login?error=missing_token', req.url) 20 ); 21 } 22 23 try { 24 const verified = await scalekit.passwordless.verifyPasswordlessEmail( 25 { linkToken }, 26 authRequestId 27 ); 28 29 createSession(verified.email); 30 return NextResponse.redirect(new URL('/dashboard', req.url)); 31 } catch { 32 return NextResponse.redirect( 33 new URL('/login?error=verification_failed', req.url) 34 ); 35 } 36 } 37 38 // OTP verification 39 export async function POST(req: NextRequest) { 40 const { code, authRequestId } = await req.json(); 41 42 if (!code || !authRequestId) { 43 return NextResponse.json( 44 { error: 'Missing required fields' }, 45 { status: 400 } 46 ); 47 } 48 49 try { 50 const verified = await scalekit.passwordless.verifyPasswordlessEmail( 51 { code }, 52 authRequestId 53 ); 54 55 createSession(verified.email); 56 return NextResponse.json({ success: true }); 57 } catch { 58 return NextResponse.json( 59 { error: 'Invalid or expired code' }, 60 { status: 400 } 61 ); 62 } 63 } ``` ### 6. Add resend endpoint [Section titled “6. Add resend endpoint”](#6-add-resend-endpoint) Create `app/api/auth/resend-passwordless/route.ts`: ```typescript 1 import Scalekit from '@scalekit-sdk/node'; 2 import { NextRequest, NextResponse } from 'next/server'; 3 4 const scalekit = new Scalekit( 5 process.env.SCALEKIT_ENVIRONMENT_URL!, 6 process.env.SCALEKIT_CLIENT_ID!, 7 process.env.SCALEKIT_CLIENT_SECRET! 8 ); 9 10 export async function POST(req: NextRequest) { 11 const { authRequestId } = await req.json(); 12 13 if (!authRequestId) { 14 return NextResponse.json( 15 { error: 'Missing authRequestId' }, 16 { status: 400 } 17 ); 18 } 19 20 try { 21 const response = await scalekit.passwordless.resendPasswordlessEmail( 22 authRequestId 23 ); 24 25 return NextResponse.json({ 26 authRequestId: response.authRequestId, 27 expiresAt: response.expiresAt, 28 }); 29 } catch { 30 return NextResponse.json( 31 { error: 'Resend failed' }, 32 { status: 400 } 33 ); 34 } 35 } ``` ### 7. Protect routes with middleware [Section titled “7. Protect routes with middleware”](#7-protect-routes-with-middleware) Create `middleware.ts` in your project root: ```typescript 1 import { NextRequest, NextResponse } from 'next/server'; 2 3 export function middleware(req: NextRequest) { 4 const protectedPath = req.nextUrl.pathname.startsWith('/dashboard'); 5 const hasSession = Boolean(req.cookies.get('session')?.value); 6 7 if (protectedPath && !hasSession) { 8 const url = new URL('/login', req.url); 9 url.searchParams.set('next', req.nextUrl.pathname); 10 return NextResponse.redirect(url); 11 } 12 13 return NextResponse.next(); 14 } 15 16 export const config = { 17 matcher: ['/dashboard/:path*'], 18 }; ``` ### 8. Build login UI (example) [Section titled “8. Build login UI (example)”](#8-build-login-ui-example) Create `app/login/page.tsx`: ```typescript 1 'use client'; 2 3 import { useState } from 'react'; 4 import { useRouter } from 'next/navigation'; 5 6 export default function LoginPage() { 7 const [email, setEmail] = useState(''); 8 const [authRequestId, setAuthRequestId] = useState(''); 9 const [showOtp, setShowOtp] = useState(false); 10 const [otp, setOtp] = useState(''); 11 const router = useRouter(); 12 13 async function handleSendEmail(e: React.FormEvent) { 14 e.preventDefault(); 15 16 const res = await fetch('/api/auth/send-passwordless', { 17 method: 'POST', 18 headers: { 'Content-Type': 'application/json' }, 19 body: JSON.stringify({ email }), 20 }); 21 22 const data = await res.json(); 23 setAuthRequestId(data.authRequestId); 24 setShowOtp(true); 25 } 26 27 async function handleVerifyOtp(e: React.FormEvent) { 28 e.preventDefault(); 29 30 const res = await fetch('/api/auth/verify', { 31 method: 'POST', 32 headers: { 'Content-Type': 'application/json' }, 33 body: JSON.stringify({ code: otp, authRequestId }), 34 }); 35 36 if (res.ok) { 37 router.push('/dashboard'); 38 } 39 } 40 41 return ( 42

43 {!showOtp ? ( 44 54 ) : ( 55 66 )} 67

68 ); 69 } ``` ## Security features [Section titled “Security features”](#security-features) Scalekit enforces these protections automatically: * **Rate limiting**: 2 emails per minute per address, 5 OTP attempts per 10 minutes * **Short-lived tokens**: Configure expiry from 60 seconds to 1 hour * **Same-browser enforcement**: When enabled, links can only be verified from the originating browser * **HttpOnly sessions**: Tokens never touch client JavaScript ## Error handling [Section titled “Error handling”](#error-handling) Map Scalekit errors to user-friendly messages: ```typescript 1 function getErrorMessage(error: string): string { 2 if (error.includes('expired')) { 3 return 'This link has expired. Request a new one.'; 4 } 5 if (error.includes('rate')) { 6 return 'Too many attempts. Please try again later.'; 7 } 8 if (error.includes('invalid')) { 9 return 'Invalid code. Please check and try again.'; 10 } 11 return 'Verification failed. Please try again.'; 12 } ``` ## Production checklist [Section titled “Production checklist”](#production-checklist) Before deploying: * ✅ Set `secure: true` for session cookies (enforced automatically in production) * ✅ Configure production Scalekit credentials in environment variables * ✅ Verify dashboard settings match your security requirements * ✅ Test magic link + OTP flow on multiple email clients * ✅ Set up monitoring for authentication errors and rate limit hits * ✅ Configure custom email templates with your branding ## Complete example [Section titled “Complete example”](#complete-example) Full working code is available in the [Scalekit GitHub repository](https://github.com/scalekit-developers/blogops-app-examples/tree/main/nextjs-passwordless-auth). ## Why this approach works [Section titled “Why this approach works”](#why-this-approach-works) This implementation: * **Works natively with App Router** - All sensitive operations are server-side * **Maintains full UI control** - No vendor widgets or redirects to hosted pages * **Handles cross-device gracefully** - OTP fallback covers magic link failures * **Requires no user migration** - Works on top of your existing user store * **Stays secure by default** - HttpOnly cookies, server-only verification, automatic rate limiting ## Related resources [Section titled “Related resources”](#related-resources) * [Scalekit Passwordless Auth Documentation](https://docs.scalekit.com/passwordless/) * [Next.js 15 App Router Documentation](https://nextjs.org/docs/app) * [Full tutorial blog post](https://www.scalekit.com/blog/passwordless-authentication-next-js) --- # DOCUMENT BOUNDARY --- # Configuring JWT Validation Timeouts in Spring Boot 4.0+ > Fix connection timeout errors when validating Scalekit JWT tokens in Spring Boot 4.0.0 and later versions. If you’re using Spring Boot 4.0.0 or later and experiencing connection timeout errors when validating JWT tokens from Scalekit, you’ll need to explicitly configure timeout values. This is a known issue affecting Spring Security’s OAuth2 resource server configuration. ## The problem [Section titled “The problem”](#the-problem) Your Spring Boot application successfully configures the `issuer-uri` for JWT validation: ```yaml 1 spring: 2 security: 3 oauth2: 4 resourceserver: 5 jwt: 6 issuer-uri: https://auth.scalekit.com ``` But authentication fails with timeout errors like: ```plaintext 1 java.net.SocketTimeoutException: Connect timed out 2 at org.springframework.security.oauth2.jwt.JwtDecoders.fromIssuerLocation ``` ## Why this happens [Section titled “Why this happens”](#why-this-happens) Starting with Spring Boot 4.0.0, Spring Security changed how it handles HTTP connections during JWT validation: * **Before 4.0.0**: Spring used default system timeouts (often much longer) * **After 4.0.0**: Spring enforces strict, short timeout defaults that can be too aggressive for production When your application starts or validates its first JWT token, Spring Security: 1. Fetches the OpenID Connect discovery document from `issuer-uri` 2. Retrieves the JWKS (JSON Web Key Set) to verify token signatures 3. Caches these for future validations If these initial requests timeout, authentication fails completely. ## Who needs this fix [Section titled “Who needs this fix”](#who-needs-this-fix) This issue specifically affects: * ✅ Spring Boot applications version **4.0.0 or later** * ✅ Using `issuer-uri` for JWT validation (not manual `jwk-set-uri`) * ✅ Production environments with network latency or firewall rules * ✅ Applications experiencing intermittent authentication failures You **don’t** need this if: * ❌ Using Spring Boot 3.x or earlier * ❌ Manually configuring `jwk-set-uri` instead of `issuer-uri` * ❌ Already have custom `RestTemplate` or `WebClient` configurations ## The solution [Section titled “The solution”](#the-solution) For Spring Security servlet resource servers, there are no properties to configure JWT discovery/JWKS HTTP timeouts. Use a custom `JwtDecoder` bean with `RestOperations` (for example, `RestTemplate`) and explicit timeout values: ```java 1 import org.springframework.context.annotation.Bean; 2 import org.springframework.context.annotation.Configuration; 3 import org.springframework.http.client.SimpleClientHttpRequestFactory; 4 import org.springframework.security.oauth2.jwt.JwtDecoder; 5 import org.springframework.security.oauth2.jwt.NimbusJwtDecoder; 6 import org.springframework.web.client.RestTemplate; 7 8 @Configuration 9 public class SecurityConfig { 10 11 @Bean 12 public JwtDecoder jwtDecoder() { 13 // Create a RestTemplate with custom timeouts 14 SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory(); 15 factory.setConnectTimeout(10000); // 10 seconds 16 factory.setReadTimeout(10000); // 10 seconds 17 18 RestTemplate restTemplate = new RestTemplate(factory); 19 20 // Use the custom RestTemplate for JWT validation 21 return NimbusJwtDecoder 22 .withIssuerLocation("https://auth.scalekit.com") 23 .restOperations(restTemplate) 24 .build(); 25 } 26 } ``` This gives you: * Full control over HTTP client configuration * Ability to add custom headers or interceptors * Environment-specific timeout tuning (development: 5000ms, production: 10000–15000ms) ## Verifying the fix [Section titled “Verifying the fix”](#verifying-the-fix) After applying the configuration: 1. **Restart your application** - Spring Security initializes the JWT decoder on startup 2. **Test authentication** - Make a request with a valid Scalekit JWT token 3. **Check logs** - You should see successful JWKS retrieval: ```plaintext 1 DEBUG o.s.security.oauth2.jwt.JwtDecoder - Retrieved JWKS from https://auth.scalekit.com/.well-known/jwks.json ``` If you still see timeout errors: * Verify network connectivity to `auth.scalekit.com` * Check firewall rules allowing outbound HTTPS * Increase timeout values if your network has high latency ## When to use standard Spring Security instead [Section titled “When to use standard Spring Security instead”](#when-to-use-standard-spring-security-instead) This cookbook addresses a specific Spring Boot 4.0+ timeout issue. For general JWT validation setup: * Follow the [Spring Security OAuth2 Resource Server documentation](https://docs.spring.io/spring-security/reference/servlet/oauth2/resource-server/jwt.html) * Use Scalekit’s standard Java SDK for token validation if not using Spring Security * Consider the default `issuer-uri` configuration if you’re not experiencing timeouts ## Related resources [Section titled “Related resources”](#related-resources) * [Spring Security OAuth2 Resource Server - JWT Timeouts](https://docs.spring.io/spring-security/reference/servlet/oauth2/resource-server/jwt.html#oauth2resourceserver-jwt-timeouts) * [Scalekit API reference](/apis/#tag/sessions) * [Spring Boot 4.0 Release Notes](https://github.com/spring-projects/spring-boot/wiki/Spring-Boot-4.0-Release-Notes) --- # DOCUMENT BOUNDARY --- # Trace AgentKit tool calls in LangSmith > Add LangSmith observability to a LangChain agent that uses Scalekit AgentKit tools for Gmail, Slack, GitHub, and 200+ connectors. When you hand an LLM a set of tools — Gmail, Slack, GitHub, calendar — you need to see what happened. Which tool was called, with what arguments, what came back, and how long it took. Without that visibility, debugging a misbehaving agent means guessing. [LangSmith](https://smith.langchain.com) provides that visibility for LangChain agents. Scalekit AgentKit returns native LangChain `StructuredTool` objects, which means LangSmith traces them automatically — no wrapper code, no custom callbacks. Set two environment variables and every tool call shows up as a span in your trace. This recipe builds a Python agent that fetches Gmail messages through AgentKit and traces the entire run in LangSmith. The same pattern works with any of Scalekit’s 200+ connectors. ## What you are building [Section titled “What you are building”](#what-you-are-building) * **A LangChain agent** that uses Scalekit AgentKit tools to read Gmail. * **LangSmith tracing** that captures every LLM call, tool invocation, input/output, and latency as spans in a trace. * **A verification step** confirming traces appear in the LangSmith dashboard. ## Prerequisites [Section titled “Prerequisites”](#prerequisites) * A Scalekit account at [app.scalekit.com](https://app.scalekit.com) with API credentials (**Settings → API Credentials**). * A **Gmail** connection configured under **Agent Auth → Connections**. See [Configure a connection](/agentkit/connections/). * A [LangSmith account](https://smith.langchain.com) and API key from **Settings → API Keys**. * An OpenAI API key, or a LiteLLM gateway URL with a virtual key. * **Python 3.10+** and **pip** or **uv**. 1. ## Install dependencies [Section titled “Install dependencies”](#install-dependencies) Terminal ```bash 1 pip install scalekit-sdk-python langchain-openai langsmith python-dotenv ``` `scalekit-sdk-python` includes the LangChain adapter. `langsmith` is the tracing client — importing it is enough for LangSmith to pick up traces when the environment variables are set. 2. ## Set environment variables [Section titled “Set environment variables”](#set-environment-variables) Create a `.env` file at the project root: .env ```bash 1 # Scalekit — from app.scalekit.com → Settings → API Credentials 2 # Threat: leaked credentials grant full API access to your Scalekit environment. 3 # Never commit this file to version control; add .env to .gitignore. 4 SCALEKIT_CLIENT_ID=skc_your_client_id 5 SCALEKIT_CLIENT_SECRET=skcs_your_client_secret 6 SCALEKIT_ENVIRONMENT_URL=https://your-subdomain.scalekit.dev 7 8 # LangSmith — from smith.langchain.com → Settings → API Keys 9 # Threat: exposed API key allows unauthorized trace reads and writes. 10 LANGCHAIN_TRACING_V2=true 11 LANGCHAIN_API_KEY=lsv2_your_langsmith_api_key 12 LANGCHAIN_PROJECT=scalekit-agentkit-traces 13 14 # LLM — OpenAI directly, or through a LiteLLM gateway 15 # Threat: exposed key allows unauthorized model usage billed to your account. 16 OPENAI_API_KEY=sk-your-openai-key ``` | Variable | Purpose | | ---------------------- | ------------------------------------------------------------ | | `LANGCHAIN_TRACING_V2` | Must be `true` to enable tracing | | `LANGCHAIN_API_KEY` | Your LangSmith API key (starts with `lsv2_`) | | `LANGCHAIN_PROJECT` | Project name in LangSmith — auto-created if it doesn’t exist | 3. ## Connect a user to Gmail [Section titled “Connect a user to Gmail”](#connect-a-user-to-gmail) Initialize the Scalekit client and ensure the user has an active Gmail connection: langsmith\_tracing.py ```python 1 import os 2 from dotenv import load_dotenv 3 4 load_dotenv() 5 6 import scalekit.client 7 8 scalekit_client = scalekit.client.ScalekitClient( 9 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 10 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 11 env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"), 12 ) 13 actions = scalekit_client.actions 14 15 IDENTIFIER = "user_123" 16 17 response = actions.get_or_create_connected_account( 18 connection_name="gmail", 19 identifier=IDENTIFIER, 20 ) 21 if response.connected_account.status != "ACTIVE": 22 link = actions.get_authorization_link( 23 connection_name="gmail", 24 identifier=IDENTIFIER, 25 ) 26 print("Authorize Gmail:", link.link) 27 input("Press Enter after authorizing...") 28 else: 29 print(f"✅ Gmail connected for {IDENTIFIER}") ``` `get_or_create_connected_account` returns an existing session if one exists. If the user hasn’t authorized yet, `get_authorization_link` returns a URL the user opens in a browser. Scalekit handles the full OAuth exchange, validates the redirect callback, and stores the token. Your application never sees the `client_secret` used in the token exchange — Scalekit manages that server-side, which prevents credential leakage from frontend or agent code. 4. ## Load tools and run the agent [Section titled “Load tools and run the agent”](#load-tools-and-run-the-agent) `actions.langchain.get_tools()` returns a list of `StructuredTool` objects. Bind them to a model and run a standard tool-calling loop: langsmith\_tracing.py ```python 1 from langchain_core.messages import HumanMessage, ToolMessage 2 from langchain_openai import ChatOpenAI 3 4 tools = actions.langchain.get_tools( 5 identifier=IDENTIFIER, 6 connection_names=["gmail"], 7 ) 8 tool_map = {t.name: t for t in tools} 9 print(f"✅ Loaded {len(tools)} LangChain tools: {[t.name for t in tools[:5]]}") 10 11 llm = ChatOpenAI(model="gpt-4o").bind_tools(tools) 12 messages = [HumanMessage("Fetch my last 3 unread emails and summarize them")] 13 14 while True: 15 response = llm.invoke(messages) 16 messages.append(response) 17 if not response.tool_calls: 18 print(response.content) 19 break 20 for tc in response.tool_calls: 21 print(f" 🔧 Tool call: {tc['name']}") 22 result = tool_map[tc["name"]].invoke(tc["args"]) 23 messages.append(ToolMessage(content=str(result), tool_call_id=tc["id"])) ``` There is no tracing-specific code here. Because `LANGCHAIN_TRACING_V2=true` is set, LangSmith automatically instruments every `invoke` call — LLM requests, tool calls, and the full message chain. 5. ## Run and verify [Section titled “Run and verify”](#run-and-verify) Terminal ```bash 1 python langsmith_tracing.py ``` Expected output (the first line appears only if the account is already `ACTIVE`; on first run you will see the authorization URL instead): Terminal ```text ✅ Gmail connected for user_123 ✅ Loaded 8 LangChain tools: ['gmail_fetch_mails', 'gmail_send_mail', ...] 🔧 Tool call: gmail_fetch_mails Here are your 3 most recent unread emails: ... ``` Open [LangSmith](https://smith.langchain.com), select the **scalekit-agentkit-traces** project, and click the latest trace. You should see: * A **ChatOpenAI** span for the LLM call * A **gmail\_fetch\_mails** tool span showing the input arguments and the structured response from Gmail * Latency, token counts, and the full message chain ## Common mistakes [Section titled “Common mistakes”](#common-mistakes) ## Production notes [Section titled “Production notes”](#production-notes) **Token refresh is automatic.** Scalekit stores OAuth tokens per user per connector and refreshes them before expiry. Your agent code never handles refresh tokens directly. **Add multiple connectors.** Pass additional connection names to `get_tools()` to load tools from Gmail, Slack, GitHub, and others in a single call. LangSmith traces all of them identically. **Trace metadata.** Use LangSmith’s `@traceable` decorator or `with_config({"tags": [...]})` to add custom tags, metadata, or run names to your traces for filtering. **Cost tracking.** LangSmith captures token counts per LLM call. Combined with tool call traces, you get full-cost visibility per agent run. ## Next steps [Section titled “Next steps”](#next-steps) * [Configure more AgentKit connectors](/agentkit/connectors/) — add Slack, GitHub, Salesforce, and 200+ others alongside Gmail. * [Virtual MCP Servers](/agentkit/mcp/overview/) — serve AgentKit tools over MCP for use with any MCP-compatible client. * [LangSmith evaluation](https://docs.smith.langchain.com/evaluation) — score agent responses and tool usage across test datasets. * [LangSmith trace filtering](https://docs.smith.langchain.com/how_to_guides/tracing/filter_traces_in_application) — filter traces by metadata, tags, latency, or error status. ## Related resources [Section titled “Related resources”](#related-resources) | Topic | Link | | ------------------------- | --------------------------------------------------------------------------------- | | AgentKit overview | [Overview](/agentkit/overview/) | | LangChain framework guide | [LangChain](/agentkit/examples/langchain/) | | Connections | [Configure a connection](/agentkit/connections/) | | Connected accounts | [Manage connected accounts](/agentkit/connected-accounts/) | | Sample repository | [agent-auth-examples](https://github.com/scalekit-developers/agent-auth-examples) | | LangSmith docs | [docs.smith.langchain.com](https://docs.smith.langchain.com) | --- # DOCUMENT BOUNDARY --- # Triage a Gmail inbox with AgentKit and the LiteLLM gateway > Node.js inbox triage agent: classify Gmail threads, route to GitHub repos, draft issues and replies via LiteLLM, and approve before any side effects. Build an automated inbox triage agent that reads your Gmail, classifies each thread, routes it to the right GitHub repository, and notifies Slack — then waits for your approval before creating issues or sending replies. This Node.js sample uses **Scalekit AgentKit** for OAuth tool execution (Gmail, GitHub, Slack) and a **LiteLLM gateway** for model-per-stage routing. The only LiteLLM-specific config is `LITELLM_BASE_URL` and a virtual API key from the dashboard. The sample repository is **[litellm-agentkit-inbox-triage](https://github.com/scalekit-developers/litellm-agentkit-inbox-triage)** on GitHub. ## What you are building [Section titled “What you are building”](#what-you-are-building) * **Gmail ingestion** — Poll for new threads using AgentKit-executed Gmail tools. A SQLite cursor prevents duplicate processing. * **Model-per-stage routing** — Each stage (`classify`, `research`, `tiebreak`, `draft`) calls the LiteLLM gateway with a different model name. Stage-to-model assignments live in `routing.yaml` at the repo root. * **Deterministic GitHub routing** — Keyword rules in `routing.yaml` pick a target repository; an optional LLM tie-breaker resolves ties. * **Research loop** — A small tool-calling loop searches related GitHub issues through AgentKit. * **Slack notification** — Posts a summary with a link to the pending decision. * **Human approval** — A localhost dashboard lists proposals. **Approve** creates the GitHub issue, sends the Gmail reply, and updates Slack. **Reject** discards without side effects. ## Automated triage pipeline [Section titled “Automated triage pipeline”](#automated-triage-pipeline) New Gmail threads flow through AgentKit into a multi-stage LiteLLM pipeline, then land in SQLite as pending proposals. ## Human approval loop [Section titled “Human approval loop”](#human-approval-loop) Proposals wait in SQLite until you review them from the dashboard. ## Prerequisites [Section titled “Prerequisites”](#prerequisites) * A Scalekit account at [app.scalekit.com](https://app.scalekit.com). * Ability to create **AgentKit connections** for **Gmail**, **GitHub**, and **Slack**. Connection **names** must match what you put in `.env` (see [Configure a connection](/agentkit/connections/)). * A **virtual LiteLLM API key** from the dashboard (**LLM Gateway**). A small spend cap of roughly two US dollars covers a handful of test threads. * **Node.js 24 or newer** and **npm**. * An **interactive terminal** — the sample prints authorization links and waits for Enter after each connector. This recipe does not cover headless CI. 1. ## Clone the sample [Section titled “Clone the sample”](#clone-the-sample) ```bash 1 git clone https://github.com/scalekit-developers/litellm-agentkit-inbox-triage.git 2 cd litellm-agentkit-inbox-triage ``` 2. ## Configure AgentKit connections [Section titled “Configure AgentKit connections”](#configure-agentkit-connections) 1. Open [app.scalekit.com](https://app.scalekit.com) → **AgentKit** → **Connections** → **Create Connection** for **Gmail**, **GitHub**, and **Slack**. 2. Copy each **Connection name** exactly as shown in the dashboard into `GMAIL_CONNECTION_NAME`, `GITHUB_CONNECTION_NAME`, and `SLACK_CONNECTION_NAME` in your `.env` file. 3. For **GitHub**, confirm the connection includes the **`repo`** OAuth scope (needed to create issues and search across repositories). Check **AgentKit → Connections → GitHub → Scopes** in the dashboard. See [Configure scopes](/agentkit/connections/#configure-scopes) and the [GitHub connector](/agentkit/connectors/github/). 4. For **Gmail** and **Slack**, follow the dashboard wizard. If your workspace restricts OAuth apps, see the connector docs: [Gmail](/agentkit/connectors/gmail/), [Slack](/agentkit/connectors/slack/). Dashboard only loads after all three connectors are active The sample calls `setupConnectors` **before** it binds the Express dashboard. You will **not** reach `http://localhost:3000` until Gmail, GitHub, and Slack each show **connector active** in the logs. 3. ## Create a LiteLLM virtual key and verify the gateway [Section titled “Create a LiteLLM virtual key and verify the gateway”](#create-a-litellm-virtual-key-and-verify-the-gateway) Open **LLM Gateway** in the Scalekit dashboard and create a **virtual API key** (optionally set a small budget cap for evaluation). Verify the gateway responds before continuing (load your `.env` first with `set -a && source .env && set +a`): ```bash 1 curl -H "Authorization: Bearer $LITELLM_API_KEY" \ 2 "$LITELLM_BASE_URL/v1/models" ``` Align `routing.yaml` → `models:` with the model IDs returned by that endpoint. 4. ## Configure and run the sample [Section titled “Configure and run the sample”](#configure-and-run-the-sample) Set these variables in `.env` before running: | Variable | Where to find it | | ------------------------ | ---------------------------------------------------- | | `SCALEKIT_ENV_URL` | Dashboard → **Settings** → Environment URL | | `SCALEKIT_CLIENT_ID` | Dashboard → **API Credentials** | | `SCALEKIT_CLIENT_SECRET` | Dashboard → **API Credentials** | | `GMAIL_CONNECTION_NAME` | Dashboard → **AgentKit → Connections** (exact label) | | `GITHUB_CONNECTION_NAME` | Same | | `SLACK_CONNECTION_NAME` | Same | | `LITELLM_BASE_URL` | Dashboard → **LLM Gateway** → Base URL | | `LITELLM_API_KEY` | Dashboard → **LLM Gateway** → virtual key value | ```bash 1 cp .env.example .env 2 # Fill in the variables above 3 4 npm install 5 npm run dev ``` Complete each printed **authorization URL** in the browser, then press **Enter** in the terminal after each connector. When you see **All connectors active** and **dashboard listening on `http://localhost:3000`**, send a test email to the connected Gmail account. Within roughly one poll interval (default **5 seconds**), a proposal appears in the dashboard. 5. ## Approve or reject [Section titled “Approve or reject”](#approve-or-reject) Open **`http://localhost:3000`**. Review the classification, routed repository, related issues, and drafts. **Approve** runs GitHub issue creation, sends the Gmail reply, and updates Slack. **Reject** leaves external systems unchanged. 6. ## Extend the sample [Section titled “Extend the sample”](#extend-the-sample) To add routing targets or swap models per stage, edit `routing.yaml` — each entry maps keyword rules to a GitHub repository and assigns a model name to each pipeline stage. To add connectors, follow the [AgentKit connections guide](/agentkit/connections/) and add the new connection name to `.env`. ## Related resources [Section titled “Related resources”](#related-resources) | Topic | Link | | ----------------------------- | --------------------------------------------------------------- | | AgentKit overview | [Overview](/agentkit/overview/) | | Connections | [Configure a connection](/agentkit/connections/) | | Authorization links | [Authorize a user](/agentkit/tools/authorize/) | | Connected accounts | [Manage connected accounts](/agentkit/connected-accounts/) | | LiteLLM virtual keys | [Virtual keys](https://docs.litellm.ai/docs/proxy/virtual_keys) | | LiteLLM model routing | [Router](https://docs.litellm.ai/docs/routing) | | LiteLLM OpenAI-compatible API | [Proxy usage](https://docs.litellm.ai/docs/proxy/user_keys) | ## Common scenarios [Section titled “Common scenarios”](#common-scenarios) For deeper debugging patterns, see [Troubleshoot connection errors](/agentkit/authentication/troubleshooting/). --- # DOCUMENT BOUNDARY --- # Build a LiveKit voice agent with Scalekit AgentKit tools > Give a LiveKit voice agent secure access to Google Calendar and 200+ AgentKit connectors — no token ever reaches the browser or the LLM. A voice agent that answers “what’s on my calendar?” needs a Google OAuth token scoped to that specific user. [LiveKit](https://livekit.io) handles the realtime voice pipeline — speech-to-text, the LLM turn, text-to-speech, turn detection — but it has no built-in concept of per-user third-party credentials. Wire that up yourself and you’re building a token vault, a refresh cycle, and a way to keep both out of reach of the browser and the LLM, before you’ve written a single line of agent logic. Scalekit AgentKit removes that layer. It stores one OAuth session per connector per user and exposes a single `executeTool` call that runs any of 200+ connector actions on that user’s behalf. This cookbook connects a LiveKit Node.js agent to AgentKit directly — no MCP server, no separate auth service — and shows the one non-obvious part: getting the *identity* of the person talking to the agent from the browser to the worker process without ever exposing a credential. ## What you are building [Section titled “What you are building”](#what-you-are-building) * **A Next.js route** that dispatches a LiveKit agent into a room and mints a browser access token, carrying a Scalekit connection identifier through LiveKit’s dispatch `metadata` — the only channel between the two. * **A standalone LiveKit agent worker** (a separate Node process, not a Next.js route) that reads that identifier from `ctx.job.metadata` and calls `scalekit.actions.executeTool()` directly when the LLM decides to check the calendar. * **A pattern that generalizes**: swap `googlecalendar_list_events` for any AgentKit tool name and the identity-passing mechanism stays identical. The complete, working source (including the Next.js UI, both API routes, and the agent) is in [livekit-scalekit-voice-agent](https://github.com/scalekit-developers/livekit-scalekit-voice-agent). ## Prerequisites [Section titled “Prerequisites”](#prerequisites) * A [LiveKit Cloud](https://cloud.livekit.io) project — copy `LIVEKIT_URL`, `LIVEKIT_API_KEY`, `LIVEKIT_API_SECRET` from **Settings → Keys**. No `lk` CLI login is required; the app and the agent both read these three values from the environment. * A Scalekit account with **AgentKit** enabled and a `googlecalendar` connection that shows as **Active** for the identifier you’ll test with. See [Configure a connection](/agentkit/connections/). * **Node.js 20.11+** — the agent worker uses `import.meta.filename`, which older Node versions don’t have. 1. ## Install dependencies [Section titled “Install dependencies”](#install-dependencies) This is a two-process app: a Next.js frontend/API layer, and a standalone agent worker that runs as a separate `tsx` process. Terminal ```bash 1 npm install @scalekit-sdk/node livekit-server-sdk livekit-client @livekit/components-react @livekit/agents zod next react react-dom 2 npm install -D tsx typescript ``` `@livekit/agents` is the Node Agents SDK — it ships the `voice.AgentSession` pipeline, the `defineAgent`/`cli.runApp` worker entrypoint, and the `llm.tool()` helper for function tools. `@scalekit-sdk/node` is the same Scalekit client either side of this app uses to call AgentKit. 2. ## Set environment variables [Section titled “Set environment variables”](#set-environment-variables) Create `.env.local` at the project root: .env.local ```bash 1 # Scalekit — Settings → API Credentials in your Scalekit dashboard 2 SCALEKIT_ENV_URL=https://your-env.scalekit.com 3 SCALEKIT_CLIENT_ID=skc_your_client_id 4 SCALEKIT_CLIENT_SECRET=your_client_secret 5 6 # Demo-only stand-in for a real authenticated user's identifier 7 TEST_IDENTIFIER=user@example.com 8 9 # LiveKit Cloud — Settings → Keys 10 LIVEKIT_URL=wss://your-project.livekit.cloud 11 LIVEKIT_API_KEY=your_api_key 12 LIVEKIT_API_SECRET=your_api_secret ``` `TEST_IDENTIFIER` stands in for whatever your app uses to identify a logged-in user. In production this comes from the authenticated session, never from a static env var — see [Production notes](#production-notes). 3. ## Carry the identifier through LiveKit dispatch metadata [Section titled “Carry the identifier through LiveKit dispatch metadata”](#carry-the-identifier-through-livekit-dispatch-metadata) The Next.js route that starts a call is the only place that decides which Scalekit identity the agent runs as. It never sends a token — just the identifier — inside LiveKit’s own `metadata` field on the agent dispatch: app/api/livekit/start/route.ts ```typescript 1 import { randomUUID } from 'node:crypto'; 2 import { NextResponse } from 'next/server'; 3 import { AccessToken, AgentDispatchClient } from 'livekit-server-sdk'; 4 5 const AGENT_NAME = 'scalekit-voice-agent'; 6 7 export async function POST(req: Request) { 8 const livekitUrl = process.env.LIVEKIT_URL!; 9 const apiKey = process.env.LIVEKIT_API_KEY!; 10 const apiSecret = process.env.LIVEKIT_API_SECRET!; 11 12 const { identifier } = await req.json(); 13 const roomName = `voice-${randomUUID()}`; 14 const metadata = JSON.stringify({ scalekitConnectionId: identifier }); 15 16 const dispatchClient = new AgentDispatchClient(livekitUrl, apiKey, apiSecret); 17 await dispatchClient.createDispatch(roomName, AGENT_NAME, { metadata }); 18 19 const at = new AccessToken(apiKey, apiSecret, { identity: `user-${randomUUID()}` }); 20 at.addGrant({ roomJoin: true, room: roomName }); 21 const token = await at.toJwt(); 22 23 return NextResponse.json({ roomName, token, url: livekitUrl, identifier }); 24 } ``` `createDispatch(roomName, agentName, { metadata })` tells LiveKit’s cloud infrastructure to route this room to a worker registered under `agentName` — you’ll register the same string in the next step. `metadata` is a plain JSON string; LiveKit stores it and hands it to the worker’s job context untouched. The browser only ever receives `token` (a room-join JWT) and `roomName` — never a Scalekit credential. This is the entire security boundary Everything downstream trusts that `identifier` came from your authenticated backend, not from user input. In this demo it falls back to `TEST_IDENTIFIER` for convenience — in production, derive it from the session on the server, never from a request body field a client could set directly. 4. ## Read the identifier and call the tool directly [Section titled “Read the identifier and call the tool directly”](#read-the-identifier-and-call-the-tool-directly) The agent worker is a separate file, run as its own process — not a Next.js route. It parses the same metadata shape the dispatch call sent, then wires a Scalekit-backed function tool: agent/src/agent.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node'; 2 import { cli, defineAgent, llm, ServerOptions, voice, type JobContext } from '@livekit/agents'; 3 import { z } from 'zod'; 4 5 const scalekit = new ScalekitClient( 6 process.env.SCALEKIT_ENV_URL!, 7 process.env.SCALEKIT_CLIENT_ID!, 8 process.env.SCALEKIT_CLIENT_SECRET!, 9 ); 10 11 const entry = async (ctx: JobContext): Promise => { 12 await ctx.connect(); 13 14 const metadata = JSON.parse(ctx.job.metadata || '{}') as { scalekitConnectionId?: string }; 15 const identifier = metadata.scalekitConnectionId || process.env.TEST_IDENTIFIER || 'demo-connection'; 16 17 const googlecalendar_list_events = llm.tool({ 18 description: "List events from the user's Google Calendar. Use this when the user asks about their schedule.", 19 parameters: z.object({ 20 calendar_id: z.string().optional().describe("Defaults to 'primary'."), 21 }), 22 execute: async ({ calendar_id }) => { 23 const result = await scalekit.actions.executeTool({ 24 connector: 'googlecalendar', 25 identifier, 26 toolName: 'googlecalendar_list_events', 27 toolInput: { calendar_id: calendar_id ?? 'primary' }, 28 }); 29 return result.data ?? result; 30 }, 31 }); 32 33 const agent = new voice.Agent({ 34 instructions: "You are a helpful voice assistant. Check the user's calendar when asked.", 35 tools: { googlecalendar_list_events }, 36 }); 37 38 const session = new voice.AgentSession({ 39 llm: 'openai/gpt-4o-mini', 40 stt: 'assemblyai/universal-streaming', 41 tts: 'cartesia/sonic-2', 42 }); 43 44 await session.start({ agent, room: ctx.room }); 45 await session.generateReply({ instructions: 'Greet the user and offer to help with their calendar.' }); 46 }; 47 48 export default defineAgent({ entry }); 49 50 cli.runApp(new ServerOptions({ agent: import.meta.filename, agentName: 'scalekit-voice-agent' })); ``` Three things worth naming explicitly: * **`llm.tool()`’s object key is the tool’s name** — there’s no `name` field inside the call. The LLM sees the tool as `googlecalendar_list_events` because that’s the key in the `tools: { googlecalendar_list_events }` map. * **`voice.Agent` is a plain constructor** — `new voice.Agent({ instructions, tools })`. There’s no static factory method. * **The three model strings are [LiveKit Inference](https://docs.livekit.io/agents/) identifiers**, not your own API keys. They route STT/LLM/TTS through LiveKit Cloud’s gateway, billed to your LiveKit project — no separate OpenAI, AssemblyAI, or Cartesia account needed to get this running. `agentName: 'scalekit-voice-agent'` must match the string `AgentDispatchClient.createDispatch()` used in step 3 exactly. That’s the only thing connecting the two processes — get it wrong and the dispatch succeeds, a room gets created, and the agent simply never joins it. 5. ## Run both processes [Section titled “Run both processes”](#run-both-processes) Terminal 1 — Next.js app ```bash 1 npm run dev ``` Terminal 2 — agent worker ```bash 1 npx tsx watch --env-file=.env.local agent/src/agent.ts dev ``` `--env-file` matters here: Next.js loads `.env.local` automatically, but a plain `tsx` process doesn’t unless you tell it to. ## Testing [Section titled “Testing”](#testing) Confirm the identity actually reaches the agent before wiring up a browser. Hit the dispatch route directly: Terminal ```bash 1 curl -X POST http://localhost:3000/api/livekit/start \ 2 -H 'Content-Type: application/json' \ 3 -d '{"identifier":"user@example.com"}' ``` The agent worker’s terminal should log the same identifier within a couple of seconds: Terminal 2 output ```text [scalekit-voice-agent] job=AJ_giyT9fjSxPg8 room=voice-2eb7cc3d-... identifier=user@example.com ``` If that line doesn’t appear, the agent never received the dispatch — see [Common mistakes](#common-mistakes) below before checking anything else. Once it does, open your frontend, click **Start**, and ask “what’s on my calendar today?” — the agent should call `executeTool`, get back real calendar data, and speak a summary. ## Common mistakes [Section titled “Common mistakes”](#common-mistakes) ## Production notes [Section titled “Production notes”](#production-notes) **No token ever reaches the browser or the LLM.** The Next.js route returns a room-join JWT (scoped to one room) and the identifier string — never a Scalekit credential. The agent worker is the only process that ever constructs a `ScalekitClient`, and `executeTool()`’s result — plain calendar data — is the only thing that reaches the LLM. **MCP isn’t available in this SDK yet.** As of `@livekit/agents` 1.4.11, there is no MCP toolset for the Node Agents SDK — direct `executeTool()` calls, as shown above, are the only path. Check the installed version’s type declarations before assuming otherwise; this changes over time. **Derive the identifier from a real session, not a static env var.** `TEST_IDENTIFIER` is a demo convenience. In production, read it from your authenticated user’s session on the server that handles the dispatch request — never from a client-supplied field. **Add more tools by changing one string.** The `connector`/`toolName` pair in `executeTool()` is the only connector-specific part of this code. Swap `googlecalendar_list_events` for any of [200+ AgentKit connectors](/agentkit/connectors/) and the identity-passing mechanism is unchanged. ## Next steps [Section titled “Next steps”](#next-steps) * [Configure more connectors](/agentkit/connectors/) — extend beyond Google Calendar to Gmail, Slack, or GitHub. * [Connected accounts](/agentkit/connected-accounts/) — check connection status and revoke access programmatically. * [AgentKit quickstart](/agentkit/quickstart/) — connect your first user in under five minutes. * [LiveKit Agents docs](https://docs.livekit.io/agents/) — turn detection, interruption handling, and telephony/SIP. ## Related resources [Section titled “Related resources”](#related-resources) | Topic | Link | | ------------------- | --------------------------------------------------------------------------------------------------- | | AgentKit overview | [Overview](/agentkit/overview/) | | All connectors | [Connectors](/agentkit/connectors/) | | Connected accounts | [Manage connected accounts](/agentkit/connected-accounts/) | | Sample repository | [livekit-scalekit-voice-agent](https://github.com/scalekit-developers/livekit-scalekit-voice-agent) | | LiveKit Agents docs | [docs.livekit.io/agents](https://docs.livekit.io/agents/) | --- # DOCUMENT BOUNDARY --- # M2M JWT verification with JWKS and OAuth scopes > How JSON Web Key Sets work with Scalekit, how to use the /keys endpoint to verify machine-to-machine tokens, and how OAuth scopes map to JWT claims for authorization. When you add OAuth 2.0 client credentials for your APIs, callers receive **JWT access tokens**. Before you trust any claim, you must **verify the signature** using Scalekit’s public keys (**JWKS**). After verification, you **authorize** the request—often by checking **OAuth scopes** carried in the token. This cookbook explains how JWKS and scopes fit together for Scalekit M2M flows: where keys live, how verification works at a high level, how scopes are defined and stored, and how to enforce them in your service. ## Why JWKS and scopes belong in one place [Section titled “Why JWKS and scopes belong in one place”](#why-jwks-and-scopes-belong-in-one-place) * **JWKS answers “is this token real?”** — You use the key identified by `kid` in the JWT header to validate the signature (typically **RS256**). * **Scopes answer “what may this client do?”** — After the token is valid, you inspect the `scopes` claim (and your routing rules) to allow or deny the operation. Skipping either step breaks your security model: verified-but-overpowered clients, or unverified tokens. ## JWKS and Scalekit keys [Section titled “JWKS and Scalekit keys”](#jwks-and-scalekit-keys) A **JSON Web Key Set (JWKS)** is JSON that lists one or more **JWKs**—public key material identified by a `kid` (key ID). Scalekit puts the matching `kid` in the JWT header so your validator can pick the right key without baking certificates into your app. Each environment publishes signing keys at: ```http 1 GET https:///keys ``` Use the same base URL as `/oauth/token` (for example `https://your-app.scalekit.dev`). Example response shape: Example JWKS document ```json 1 { 2 "keys": [ 3 { 4 "use": "sig", 5 "kty": "RSA", 6 "kid": "snk_58327480989122566", 7 "alg": "RS256", 8 "n": "…", 9 "e": "AQAB" 10 } 11 ] 12 } ``` For access tokens, use the key where `use` is `sig` and `alg` is `RS256`. ## Verify an access token [Section titled “Verify an access token”](#verify-an-access-token) At implementation time, your API typically: 1. **Extracts** the bearer token from `Authorization: Bearer `. 2. **Decodes** the JWT header (base64url, first segment) and reads `kid` and `alg`. Do not trust the payload until the signature checks out. 3. **Resolves the signing key** — fetch `https:///keys`, or use a JWKS client (for example `jwks-rsa` in Node.js) with **caching** and refresh when you see an unknown `kid`. 4. **Verifies** the signature with your JWT library (RS256 for Scalekit access tokens). 5. **Validates claims** such as `exp`, `iss` (your environment URL), and `aud` if your API relies on audience restrictions. 6. **Authorizes** the operation using application claims—especially **`scopes`** (covered in the next section). ### Operational practices [Section titled “Operational practices”](#operational-practices) * **Cache JWKS** responses; refetch when verification fails with an unknown `kid` (key rotation). * **Fail closed** on bad signature, wrong issuer, or expired token (`401`; use `403` when the token is valid but not allowed). * **Never** skip signature verification based on the payload alone. ## OAuth scopes for machine clients [Section titled “OAuth scopes for machine clients”](#oauth-scopes-for-machine-clients) **Scopes** are permission names you attach to an OAuth client. In M2M flows they describe *what* a client may do—separate from *who* it is (`client_id` / `sub`). ### Why scopes matter [Section titled “Why scopes matter”](#why-scopes-matter) Without scopes, any valid client could hit any endpoint. Scopes let you apply **least privilege**, **document** what each integration is for, and **enforce** rules in your API by reading the `scopes` array on the JWT. ### How scopes work in Scalekit M2M [Section titled “How scopes work in Scalekit M2M”](#how-scopes-work-in-scalekit-m2m) 1. When you **register an API client** for an organization, you pass a `scopes` array (REST or SDKs). 2. Scalekit stores those scopes and includes them on issued access tokens. 3. Your API **verifies the JWT** (steps above), then checks that `scopes` includes what the route requires. Use a consistent naming pattern such as `resource:action` (for example `deployments:read`, `deployments:write`). ### Register scopes on the client [Section titled “Register scopes on the client”](#register-scopes-on-the-client) Scopes are set at **client creation** (and when you update the client via the API). Example: scopes on create client (illustrative) ```json 1 "scopes": [ 2 "deploy:applications", 3 "read:deployments" 4 ] ``` The same values appear on the client record and in issued tokens. ### Validate scopes on your API [Section titled “Validate scopes on your API”](#validate-scopes-on-your-api) After the token is verified: * **Read `scopes`** from the payload, for example: scopes in JWT payload (example) ```json 1 "scopes": [ 2 "deploy:applications", 3 "read:deployments" 4 ] ``` * **Compare** what the token grants to what the route allows (for example require `deploy:applications` on `POST /deploy`); return `403` if a required scope is missing. * **Use SDK helpers** where they fit your stack to combine signature and scope checks (see the [quickstart](/authenticate/m2m/api-auth-quickstart/)). ## Related [Section titled “Related”](#related) * [Add OAuth 2.0 to your APIs](/authenticate/m2m/api-auth-quickstart/) — client registration, tokens, examples * [API keys](/authenticate/m2m/api-keys/) — long-lived keys; patterns may differ from OAuth client credentials * [Authenticate customer apps](/guides/m2m/api-auth-m2m-clients/) — customer-facing API auth and JWKS examples --- # DOCUMENT BOUNDARY --- # Build a Mastra agent with Scalekit AgentKit tools > Give a Mastra agent access to Gmail and 200+ connectors through Scalekit AgentKit — zero manual OAuth handling. A [Mastra](https://mastra.ai) agent that reads emails needs a Gmail OAuth token. An agent that also posts to Slack needs a second token. Each tool means another OAuth flow, another token store, another refresh cycle. Before you write any agent logic, you are already maintaining parallel credential pipelines. Scalekit AgentKit eliminates that overhead. It stores one OAuth session per connector per user, handles token refresh automatically, and gives your agent a single API surface for 200+ connectors. This recipe shows how to discover AgentKit tools at runtime, wrap them as native Mastra tools, and run them through a Mastra agent — all in TypeScript, with no Python backend. ## What you are building [Section titled “What you are building”](#what-you-are-building) * **A Mastra agent** that fetches Gmail messages through Scalekit AgentKit. * **Dynamic tool discovery** — the agent discovers available tools at runtime from Scalekit, instead of hardcoding tool definitions. * **Magic link authorization** — if the user has not connected their Gmail account, the agent generates an authorization URL. * **A pattern you can extend** to any of Scalekit’s [200+ connectors](/agentkit/connectors/) by changing a single string. The complete source is available in the [mastra-agentkit-example](https://github.com/scalekit-developers/mastra-agentkit-example) repository. ## Prerequisites [Section titled “Prerequisites”](#prerequisites) * A Scalekit account at [app.scalekit.com](https://app.scalekit.com) with API credentials (**Settings → API Credentials**). * A **Gmail** connection configured under **AgentKit → Connections**. See [Configure a connection](/agentkit/connections/). * An OpenAI API key. * **Node.js 18+** and **pnpm** (or npm). 1. ## Install dependencies [Section titled “Install dependencies”](#install-dependencies) Terminal ```bash 1 pnpm add @mastra/core @scalekit-sdk/node @ai-sdk/openai zod dotenv 2 pnpm add -D tsx typescript @types/node ``` `@mastra/core` provides the `Agent` and `createTool` primitives. `@scalekit-sdk/node` handles authentication, tool discovery, and tool execution against the Scalekit API. `@ai-sdk/openai` connects the agent to GPT-4o. 2. ## Set environment variables [Section titled “Set environment variables”](#set-environment-variables) Create a `.env` file at the project root: .env ```bash 1 # Scalekit — from app.scalekit.com → Settings → API Credentials 2 # Threat: leaked credentials grant full API access to your Scalekit environment. 3 # Never commit this file to version control; add .env to .gitignore. 4 SCALEKIT_ENV_URL=https://your-env.scalekit.dev 5 SCALEKIT_CLIENT_ID=skc_your_client_id 6 SCALEKIT_CLIENT_SECRET=your_client_secret 7 8 # OpenAI 9 # Threat: exposed key allows unauthorized model usage billed to your account. 10 OPENAI_API_KEY=sk-your-openai-key 11 12 # User and connection — replace with values from your application 13 USER_IDENTIFIER=user_123 14 CONNECTION_NAME=gmail ``` | Variable | Purpose | | ------------------------ | --------------------------------------------------------- | | `SCALEKIT_ENV_URL` | Your Scalekit environment URL (starts with `https://`) | | `SCALEKIT_CLIENT_ID` | Client ID from API Credentials (starts with `skc_`) | | `SCALEKIT_CLIENT_SECRET` | Client secret from API Credentials | | `OPENAI_API_KEY` | OpenAI API key for GPT-4o | | `USER_IDENTIFIER` | A unique identifier for the end user in your application | | `CONNECTION_NAME` | The connection name configured in your Scalekit dashboard | 3. ## Initialize Scalekit and ensure the user is connected [Section titled “Initialize Scalekit and ensure the user is connected”](#initialize-scalekit-and-ensure-the-user-is-connected) Create `src/index.ts`. Start by initializing the Scalekit client and checking whether the user has an active Gmail connection: src/index.ts ```typescript 1 import { Agent } from '@mastra/core/agent'; 2 import { createTool } from '@mastra/core/tools'; 3 import { openai } from '@ai-sdk/openai'; 4 import { ScalekitClient } from '@scalekit-sdk/node'; 5 import { z } from 'zod'; 6 import 'dotenv/config'; 7 8 const IDENTIFIER = process.env.USER_IDENTIFIER || 'user_123'; 9 const CONNECTION = process.env.CONNECTION_NAME || 'gmail'; 10 11 const scalekit = new ScalekitClient( 12 process.env.SCALEKIT_ENV_URL!, 13 process.env.SCALEKIT_CLIENT_ID!, 14 process.env.SCALEKIT_CLIENT_SECRET!, 15 ); 16 17 const { connectedAccount } = await scalekit.actions.getOrCreateConnectedAccount({ 18 connectionName: CONNECTION, 19 identifier: IDENTIFIER, 20 }); 21 22 if (connectedAccount?.status?.toString() !== '1') { 23 const { link } = await scalekit.actions.getAuthorizationLink({ 24 connectionName: CONNECTION, 25 identifier: IDENTIFIER, 26 }); 27 console.log(`\n[${CONNECTION}] Authorization required.`); 28 console.log(`Open this link:\n\n ${link}\n`); 29 console.log('Press Enter once you have completed the OAuth flow...'); 30 await new Promise((resolve) => { 31 process.stdin.resume(); 32 process.stdin.once('data', () => { process.stdin.pause(); resolve(); }); 33 }); 34 } ``` `getOrCreateConnectedAccount` returns an existing session if one exists or creates a pending one. If the account is not active (status `1`), `getAuthorizationLink` returns a URL you open in a browser. Scalekit handles the full OAuth exchange — your application never sees the provider’s client secret. 4. ## Discover tools from Scalekit [Section titled “Discover tools from Scalekit”](#discover-tools-from-scalekit) Once the user is connected, list the tools available for their account: src/index.ts (continued) ```typescript 1 const toolsResponse = await scalekit.tools.listTools({ 2 filter: { connector: CONNECTION, identifier: IDENTIFIER }, 3 pageSize: 50, 4 }); 5 6 const scalekitTools = toolsResponse.tools; 7 console.log( 8 `Discovered ${scalekitTools.length} tools: ` + 9 scalekitTools.map((t) => (t.definition as any)?.name).join(', ') 10 ); ``` `listTools` returns tool definitions that include a `name`, `description`, and `input_schema` (a JSON Schema object). The `filter` parameter scopes results to the connector and user — the agent only sees tools the user has authorized. 5. ## Convert Scalekit tools to Mastra tools [Section titled “Convert Scalekit tools to Mastra tools”](#convert-scalekit-tools-to-mastra-tools) Mastra agents accept tools created with `createTool`. Each Scalekit tool needs to be wrapped: src/index.ts (continued) ```typescript 1 const mastraTools: Record> = {}; 2 3 for (const tool of scalekitTools) { 4 const def = tool.definition as Record | undefined; 5 if (!def?.name) continue; 6 7 const toolName: string = def.name; 8 const description: string = def.description || toolName; 9 10 // Use a permissive Zod schema — Scalekit validates inputs server-side. 11 const inputSchema = z.object({}).passthrough(); 12 13 mastraTools[toolName] = createTool({ 14 id: toolName, 15 description, 16 inputSchema, 17 execute: async ({ context }) => { 18 const result = await scalekit.tools.executeTool({ 19 toolName, 20 identifier: IDENTIFIER, 21 params: context as Record, 22 }); 23 return result; 24 }, 25 }); 26 } ``` The `inputSchema` uses `z.object({}).passthrough()` — a permissive schema that lets the LLM pass any parameters through. Scalekit validates inputs server-side, so client-side validation is optional. If you want stricter types, convert the JSON Schema from `def.input_schema` into a typed Zod schema. The `execute` function calls `scalekit.tools.executeTool()`, which sends the tool call to Scalekit. Scalekit injects the user’s OAuth token, calls the third-party API, and returns the structured response. 6. ## Build and run the agent [Section titled “Build and run the agent”](#build-and-run-the-agent) Create the Mastra agent with the discovered tools and run it: src/index.ts (continued) ```typescript 1 const agent = new Agent({ 2 name: 'gmail-assistant', 3 instructions: 4 'You are a helpful Gmail assistant. Use the available tools to fulfill requests. ' + 5 'Always confirm what you did after completing an action.', 6 model: openai('gpt-4o'), 7 tools: mastraTools, 8 }); 9 10 const prompt = process.argv[2] || 'Fetch my last 5 unread emails and summarize them.'; 11 console.log(`\nPrompt: ${prompt}\n`); 12 13 const result = await agent.generate(prompt); 14 console.log(result.text); ``` Add a start script to `package.json`: package.json (scripts section) ```json 1 { 2 "scripts": { 3 "start": "tsx src/index.ts" 4 } 5 } ``` 7. ## Run and verify [Section titled “Run and verify”](#run-and-verify) Terminal ```bash 1 pnpm start ``` On the first run, if the user hasn’t authorized Gmail, you see the authorization flow: Terminal ```text [gmail] Authorization required. Open this link: https://auth.scalekit.dev/connect/... Press Enter once you have completed the OAuth flow... ``` After authorization (or on subsequent runs), the agent runs: Terminal ```text Connected account for user_123 is active. Discovered 8 tools: gmail_fetch_mails, gmail_send_mail, gmail_search_mails, ... Created 8 Mastra tools. Prompt: Fetch my last 5 unread emails and summarize them. Here are your 5 most recent unread emails: 1. "Q1 roadmap feedback needed" — Sarah Chen (1h ago) Requesting feedback on the product roadmap by Friday. 2. "Deploy failed: production" — GitHub Actions (2h ago) CI pipeline failed on the main branch, test suite timeout. 3. "New PR review requested" — Lin Feng (3h ago) Review requested on PR #412: refactor auth middleware. ... ``` You can also pass a custom prompt: Terminal ```bash 1 pnpm start "Search for emails from GitHub and list the subjects" ``` ## Common mistakes [Section titled “Common mistakes”](#common-mistakes) ## Production notes [Section titled “Production notes”](#production-notes) **Token refresh is automatic.** Scalekit stores OAuth tokens per user per connector and refreshes them before expiry. Your agent code never handles refresh tokens directly. **Scope tools per user.** The `identifier` parameter in `listTools` and `executeTool` ensures each user only accesses their own connected accounts. Never share an identifier across users. **Add more connectors.** Change `CONNECTION_NAME` to `slack`, `notion`, `googlecalendar`, or any of the [200+ supported connectors](/agentkit/connectors/). The code is identical — only the connection name changes. **Error handling in production.** Wrap `executeTool` calls in try/catch to handle network errors and expired connections gracefully. Return a clear message to the user when a tool call fails instead of letting the agent retry silently. **MCP alternative.** If you prefer Mastra’s built-in MCP client over manual tool wrapping, see the [Mastra MCP example](/agentkit/examples/mastra/). That approach requires a per-user MCP URL generated from the Python SDK. ## Next steps [Section titled “Next steps”](#next-steps) * [Configure more connectors](/agentkit/connectors/) — add Slack, GitHub, Salesforce, and others alongside Gmail. * [Mastra MCP integration](/agentkit/examples/mastra/) — use Mastra’s native MCP client with a Scalekit MCP URL. * [AgentKit quickstart](/agentkit/quickstart/) — connect your first user in under five minutes. * [Connected accounts](/agentkit/connected-accounts/) — manage user connections, check status, and revoke access programmatically. ## Related resources [Section titled “Related resources”](#related-resources) | Topic | Link | | ------------------ | ----------------------------------------------------------------------------------------- | | AgentKit overview | [Overview](/agentkit/overview/) | | All connectors | [Connectors](/agentkit/connectors/) | | Connected accounts | [Manage connected accounts](/agentkit/connected-accounts/) | | Mastra MCP example | [Mastra](/agentkit/examples/mastra/) | | Sample repository | [mastra-agentkit-example](https://github.com/scalekit-developers/mastra-agentkit-example) | | Mastra docs | [mastra.ai/docs](https://mastra.ai/docs) | --- # DOCUMENT BOUNDARY --- # Migrate from Auth0 to Scalekit > Move users, organizations, and enterprise SSO off Auth0 to Scalekit Full Stack Auth with a safe, incremental cutover. Migrating a B2B app off Auth0 is risky because three things move at once: user records, the organization or tenant structure, and enterprise SSO connections. Do it in one big switch and you risk locking customers out. This recipe moves each piece to [Scalekit Full Stack Auth](/authenticate/fsa/quickstart/) in a safe, reversible order, then cuts traffic over behind a feature flag. The approach avoids re-hashing passwords. Instead of copying credentials, you point your app at Scalekit’s hosted login and let users re-authenticate through SSO, social login, or passwordless on their next visit. This is the recommended path for B2B products, where most enterprise users already sign in through an identity provider rather than a password. ## What you build [Section titled “What you build”](#what-you-build) * A field mapping from Auth0 users, organizations, and connections to Scalekit * A one-time import script that recreates organizations and users with `external_id` back-references * Enterprise SSO connections rebuilt in Scalekit for each customer that used them * An incremental cutover behind a feature flag, with a rollback path ## Who needs this [Section titled “Who needs this”](#who-needs-this) This recipe is for you if: * You authenticate a B2B or multi-tenant app on Auth0 today, using Auth0 Organizations or per-tenant connections. * You want Scalekit to own hosted login, sessions, enterprise SSO, and SCIM going forward. * You can run a short backfill script and toggle a feature flag in your app. ## Prerequisites [Section titled “Prerequisites”](#prerequisites) * An Auth0 tenant with a Machine-to-Machine application authorized for the Auth0 Management API. * A Scalekit account with API credentials from the dashboard. See [Set up Scalekit](/authenticate/fsa/quickstart/). * The Scalekit SDK installed in your backend. ## How Auth0 concepts map to Scalekit [Section titled “How Auth0 concepts map to Scalekit”](#how-auth0-concepts-map-to-scalekit) Start from the data model. Every later step follows this mapping. | Auth0 concept | Scalekit concept | Notes | | ------------------------------------ | -------------------- | -------------------------------------------------------------------------------------- | | Organization | Organization | Store the Auth0 `org_id` as the Scalekit `external_id`. | | User | User + membership | Users belong to an organization through a membership that carries roles. | | `user_id` (for example `auth0\|abc`) | User `external_id` | Preserves lookups between systems during cutover. | | Enterprise connection (SAML, OIDC) | SSO connection | Recreated per organization in Scalekit; secrets are not exportable from Auth0. | | Roles and permissions | Roles | Recreate roles in Scalekit, then attach them to memberships on import. | | Database (password) users | Hosted login re-auth | Users re-verify through SSO, social, or passwordless. See the following password note. | ## Migrate the data [Section titled “Migrate the data”](#migrate-the-data) 1. ## Export your Auth0 data [Section titled “Export your Auth0 data”](#export-your-auth0-data) Pull three datasets from Auth0 using the [Management API](https://auth0.com/docs/api/management/v2) or the [User Import / Export extension](https://auth0.com/docs/customize/extensions/user-import-export-extension). Create a [bulk user export job](https://auth0.com/docs/manage-users/user-migration/bulk-user-exports) to get every user as newline-delimited JSON: Export Auth0 users ```bash 1 # Security: pass the Management API token from an environment variable, never inline it. 2 curl "https://YOUR_AUTH0_DOMAIN/api/v2/jobs/users-exports" \ 3 --request POST \ 4 --header "Authorization: Bearer $AUTH0_MGMT_TOKEN" \ 5 --header 'Content-Type: application/json' \ 6 --data '{ 7 "format": "json", 8 "fields": [ 9 { "name": "user_id" }, 10 { "name": "email" }, 11 { "name": "email_verified" }, 12 { "name": "given_name" }, 13 { "name": "family_name" } 14 ] 15 }' ``` Poll `GET /api/v2/jobs/{job_id}` until the job reports `completed`, then download the file it returns. Then export [organizations](https://auth0.com/docs/manage-users/organizations) and their members: Export Auth0 organizations and members ```bash 1 curl "https://YOUR_AUTH0_DOMAIN/api/v2/organizations" \ 2 --header "Authorization: Bearer $AUTH0_MGMT_TOKEN" 3 4 # For each organization id returned above: 5 curl "https://YOUR_AUTH0_DOMAIN/api/v2/organizations/{org_id}/members" \ 6 --header "Authorization: Bearer $AUTH0_MGMT_TOKEN" ``` Finally, list the enterprise connections you rebuild in Scalekit. Record the identity provider, metadata URL, and which organizations use each one. Connection secrets stay in the identity provider and are not exportable. List Auth0 enterprise connections ```bash 1 curl "https://YOUR_AUTH0_DOMAIN/api/v2/connections?strategy=samlp" \ 2 --header "Authorization: Bearer $AUTH0_MGMT_TOKEN" ``` 2. ## Install the Scalekit SDK [Section titled “Install the Scalekit SDK”](#install-the-scalekit-sdk) Add the SDK to the backend that runs your import script. * Node.js ```bash npm install @scalekit-sdk/node ``` * Python ```sh pip install scalekit-sdk-python ``` * Go ```sh go get -u github.com/scalekit-inc/scalekit-sdk-go ``` * Java ```groovy /* Gradle users - add the following to your dependencies in build file */ implementation "com.scalekit:scalekit-sdk-java:2.1.3" ``` ```xml com.scalekit scalekit-sdk-java 2.1.3 ``` 3. ## Import organizations first [Section titled “Import organizations first”](#import-organizations-first) Create each Auth0 organization in Scalekit and set `external_id` to the Auth0 `org_id`. This back-reference lets you attach users to the right organization and reconcile records during cutover. * Node.js import-organizations.js ```javascript 1 // organizations: rows read from your Auth0 organizations export 2 for (const org of organizations) { 3 const result = await scalekit.organization.createOrganization(org.display_name, { 4 externalId: org.id, // Auth0 org_id, preserved for lookups 5 metadata: { source: 'auth0' }, 6 }); 7 console.log(`Created organization: ${result.id}`); 8 } ``` * Python import\_organizations.py ```python 1 from scalekit.v1.organizations.organizations_pb2 import CreateOrganization 2 3 # organizations: rows read from your Auth0 organizations export 4 for org in organizations: 5 result = scalekit_client.organization.create_organization( 6 CreateOrganization( 7 display_name=org["display_name"], 8 external_id=org["id"], # Auth0 org_id, preserved for lookups 9 metadata={"source": "auth0"}, 10 ) 11 ) 12 print(f"Created organization: {result.id}") ``` * Go import\_organizations.go ```go 1 // organizations: rows read from your Auth0 organizations export 2 for _, org := range organizations { 3 result, err := scalekitClient.Organization.CreateOrganization( 4 ctx, 5 org.DisplayName, 6 scalekit.CreateOrganizationOptions{ 7 ExternalID: org.ID, // Auth0 org_id, preserved for lookups 8 Metadata: map[string]interface{}{"source": "auth0"}, 9 }, 10 ) 11 if err != nil { 12 log.Fatal(err) 13 } 14 fmt.Printf("Created organization: %s\n", result.ID) 15 } ``` * Java ImportOrganizations.java ```java 1 // organizations: rows read from your Auth0 organizations export 2 for (Map org : organizations) { 3 CreateOrganization createOrganization = CreateOrganization.newBuilder() 4 .setDisplayName((String) org.get("display_name")) 5 .setExternalId((String) org.get("id")) // Auth0 org_id, preserved for lookups 6 .putMetadata("source", "auth0") 7 .build(); 8 9 Organization result = scalekitClient.organizations().create(createOrganization); 10 System.out.println("Created organization: " + result.getId()); 11 } ``` 4. ## Import users into their organizations [Section titled “Import users into their organizations”](#import-users-into-their-organizations) Create each user inside the organization it belongs to, and set the user `external_id` to the Auth0 `user_id`. Attach roles through the membership so access control works on the first login. Set `sendInvitationEmail` to `false` to skip invite emails during a bulk backfill. Scalekit marks the membership `active` and treats the email as verified. * Node.js import-users.js ```javascript 1 const { user } = await scalekit.user.createUserAndMembership(organizationId, { 2 email: row.email, 3 externalId: row.user_id, // Auth0 user_id, e.g. "auth0|abc123" 4 sendInvitationEmail: false, 5 userProfile: { 6 firstName: row.given_name, 7 lastName: row.family_name, 8 }, 9 metadata: { roles: row.roles?.join(',') ?? '' }, 10 }); 11 console.log(`Created user: ${user.id}`); ``` * Python import\_users.py ```python 1 from scalekit.v1.users.users_pb2 import CreateUser 2 from scalekit.v1.commons.commons_pb2 import UserProfile 3 4 user_msg = CreateUser( 5 email=row["email"], 6 external_id=row["user_id"], # Auth0 user_id, e.g. "auth0|abc123" 7 user_profile=UserProfile( 8 first_name=row["given_name"], 9 last_name=row["family_name"], 10 ), 11 ) 12 13 create_resp, _ = scalekit_client.user.create_user_and_membership( 14 organization_id, user_msg 15 ) 16 print(f"Created user: {create_resp.user.id}") ``` * Go import\_users.go ```go 1 newUser := &usersv1.CreateUser{ 2 Email: row.Email, 3 ExternalId: row.UserID, // Auth0 user_id, e.g. "auth0|abc123" 4 UserProfile: &usersv1.CreateUserProfile{ 5 FirstName: row.GivenName, 6 LastName: row.FamilyName, 7 }, 8 } 9 10 cuResp, err := scalekitClient.User().CreateUserAndMembership(ctx, organizationID, newUser, false) 11 if err != nil { 12 log.Fatal(err) 13 } 14 fmt.Printf("Created user: %s\n", cuResp.User.Id) ``` * Java ImportUsers.java ```java 1 CreateUser createUser = CreateUser.newBuilder() 2 .setEmail(row.email) 3 .setExternalId(row.userId) // Auth0 user_id, e.g. "auth0|abc123" 4 .setUserProfile( 5 CreateUserProfile.newBuilder() 6 .setFirstName(row.givenName) 7 .setLastName(row.familyName) 8 .build()) 9 .build(); 10 11 CreateUserAndMembershipResponse cuResp = scalekitClient.users() 12 .createUserAndMembership(organizationId, createUser); 13 System.out.println("Created user: " + cuResp.getUser().getId()); ``` Batch the import and run requests in parallel for speed, but respect rate limits. Roles referenced on the membership must exist first. Create them under **User Management > Roles** or with the SDK. See [Create roles and permissions](/authenticate/authz/create-roles-permissions/). 5. ## Rebuild enterprise SSO connections [Section titled “Rebuild enterprise SSO connections”](#rebuild-enterprise-sso-connections) For every customer that signed in through an Auth0 enterprise connection, recreate the connection in Scalekit against the same identity provider. You configure this per organization, so each customer keeps its own SAML or OIDC setup. Follow [Add modular SSO](/authenticate/sso/add-modular-sso/) for each organization. Reuse the identity provider metadata you recorded during export, then re-run the identity provider’s setup to issue fresh SAML or OIDC credentials to Scalekit. Connection secrets from Auth0 cannot be reused. 6. ## Point your app at Scalekit hosted login [Section titled “Point your app at Scalekit hosted login”](#point-your-app-at-scalekit-hosted-login) Replace the Auth0 login redirect and session validation with Scalekit. * Register your callback and post-logout URLs under **Settings > Redirects**. See the [redirect URI guide](/guides/dashboard/redirects/). * Swap Auth0 SDK session middleware for the Scalekit SDK, or validate access tokens against Scalekit’s JWKS endpoint. * Read authorization from the `roles` claim that Scalekit issues, in place of Auth0 roles or scopes. 7. ## Cut over incrementally and verify [Section titled “Cut over incrementally and verify”](#cut-over-incrementally-and-verify) Roll out behind a feature flag so you can reverse the switch without a redeploy. 1. Route 5 to 10 percent of traffic to Scalekit login and confirm those users authenticate, receive sessions, and see the right roles. 2. Watch authentication success rates and error logs. Verify SSO connections resolve for enterprise organizations. 3. Increase the percentage in stages until all traffic uses Scalekit. 4. Keep the Auth0 tenant read-only until you’re confident, so rollback stays available. ## Handle password-based users [Section titled “Handle password-based users”](#handle-password-based-users) Auth0 database users authenticate with a password hash that stays inside Auth0 and can’t be exported. Two paths keep those users signed in: * **Re-authentication (recommended).** On first visit after cutover, users sign in through SSO, social login, or [passwordless](/authenticate/auth-methods/passwordless/). No password moves, and the `external_id` mapping links them back to their imported record. * **Password-hash migration.** If you must carry password hashes over, the Scalekit Solutions team handles this directly. [Contact us](/support/contact-us) before you start the import. ## Common mistakes [Section titled “Common mistakes”](#common-mistakes) ## Where to go next [Section titled “Where to go next”](#where-to-go-next) * [Migrate to Full Stack Auth](/fsa/guides/migration-guide/): the vendor-neutral migration reference this recipe builds on. * [Add modular SSO](/authenticate/sso/add-modular-sso/): rebuild each enterprise connection in Scalekit. * [Create roles and permissions](/authenticate/authz/create-roles-permissions/): set up the roles your imported memberships reference. STYLE-CHECK: PASSED --- # DOCUMENT BOUNDARY --- # Build a multi-user GitHub PR summarizer agent > Build a GitHub PR summarizer that binds each connected GitHub account to a secure browser session instead of trusting a client-supplied user ID. This recipe builds a GitHub PR summarizer with a browser UI and a secure connected-account flow. Each user connects GitHub once, then the app reuses that connected token for later PR summary requests in the same browser session. The important security rule is straightforward: **never accept a user ID from the browser and use it as the Scalekit connected-account identifier**. Instead, mint an opaque identifier on the server, store it in your own session store, and complete the flow with [user verification for connected accounts](/agentkit/user-verification/). The finished app does four things: * lists the most-discussed open pull requests in a repository * fetches each PR’s diff and comment thread through Scalekit’s GitHub connector * asks an LLM to summarize the PRs in plain language * binds every GitHub connection to a secure browser session instead of a client-supplied identifier The complete source is available in the [render-ai-agent-deploykit](https://github.com/scalekit-developers/render-ai-agent-deploykit) repository. You can also [watch the video walkthrough](https://youtu.be/w3atzSkKE1w) to see the full setup and demo end-to-end. ## What you are building [Section titled “What you are building”](#what-you-are-building) The app runs as a Node web service on Render. It serves an HTML page with a **Connect GitHub** button and a form for `owner` and `repo`. Under the hood, the flow looks like this: ```text 1 Browser (original tab) Browser (new tab) 2 │ │ 3 ▼ GET / │ 4 Express server sets signed session cookie │ 5 │ │ 6 ▼ POST /api/auth │ 7 Scalekit returns GitHub auth link │ 8 │ │ 9 │ opens auth link ─────────────────► ▼ 10 │ GitHub OAuth consent 11 │ │ 12 │ polls GET /api/auth/status ▼ 13 │ ◄─── Scalekit API: ACTIVE ──► Scalekit verifies account 14 │ 15 ▼ page auto-reloads 16 │ 17 ▼ POST /api/summarize { repository } 18 Scalekit runs GitHub requests with the connected user's token ``` The OAuth flow opens in a **new tab** so the app page stays intact. The original tab polls the Scalekit API until the connected account becomes `ACTIVE`, then auto-reloads to show the connected state. ## 1. Set up the GitHub connector [Section titled “1. Set up the GitHub connector”](#1-set-up-the-github-connector) Create the connector once per Scalekit environment. 1. Go to [app.scalekit.com](https://app.scalekit.com) → **AgentKit** > **Connections** > **Create Connection** 2. Find **GitHub** and click **Create** 3. Follow the setup — Scalekit creates and manages the GitHub OAuth app for you 4. Note the **connection name** assigned (e.g. `github-qkHFhMip`) — you’ll set this as `GITHUB_CONNECTION_NAME` in your environment Connection names are unique per environment Scalekit generates a unique GitHub connection name for each environment. Do not copy one from a tutorial or another project. Always use the exact value from your own Scalekit Dashboard. ## 2. Configure user verification (required) [Section titled “2. Configure user verification (required)”](#2-configure-user-verification-required) Scalekit’s user verification setting controls what happens after a user completes GitHub OAuth. **You must choose a mode in the dashboard before the app will work end-to-end.** Go to **AgentKit > Settings > User verification** in the [Scalekit dashboard](https://app.scalekit.com). | Mode | When to use | What happens after OAuth | | ---------------------------- | ----------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Scalekit users only** | Development and testing | Scalekit verifies the user internally. The connected account goes `ACTIVE` automatically. The app detects this by polling the Scalekit API. | | **Custom user verification** | Production | Scalekit redirects the browser to your app’s `/user/verify` callback. The server calls `verifyConnectedAccountUser` to activate the account. The app also polls the Scalekit API as a fallback. | The app works in **both modes** without code changes. If you skip this step entirely, the connected account may never reach `ACTIVE` status and the app will stay stuck on “Waiting for GitHub authorization.” This step is required This is the most common setup mistake. If you deploy the app, set all environment variables, and complete GitHub OAuth but the app never shows “GitHub connected,” check this dashboard setting first. For the full verification model, see [user verification for connected accounts](/agentkit/user-verification/). ## 3. Create the project [Section titled “3. Create the project”](#3-create-the-project) Terminal ```bash 1 mkdir render-pr-summarizer && cd render-pr-summarizer 2 npm init -y 3 npm install @renderinc/sdk @scalekit-sdk/node openai dotenv express 4 npm install -D typescript tsx @types/node @types/express ``` package.json ```json 1 { 2 "type": "module", 3 "scripts": { 4 "dev": "tsx src/main.ts", 5 "build": "tsc", 6 "start": "node dist/main.js" 7 } 8 } ``` tsconfig.json ```json 1 { 2 "compilerOptions": { 3 "target": "ES2022", 4 "module": "NodeNext", 5 "moduleResolution": "NodeNext", 6 "outDir": "dist", 7 "strict": true 8 }, 9 "include": ["src"] 10 } ``` ## 4. Configure environment variables [Section titled “4. Configure environment variables”](#4-configure-environment-variables) Terminal ```bash 1 cp .env.example .env ``` .env ```bash 1 PORT=3000 2 SESSION_SECRET=replace-with-openssl-rand-hex-32 3 4 OPENAI_API_KEY=your-api-key 5 OPENAI_MODEL=gpt-4.1-mini 6 # Leave OPENAI_BASE_URL empty for OpenAI direct. 7 # Set it to a proxy URL for LiteLLM, Azure OpenAI, Ollama, etc. 8 # OPENAI_BASE_URL=https://your-litellm-proxy.example.com 9 10 SCALEKIT_ENVIRONMENT_URL=https://your-env.scalekit.com 11 SCALEKIT_CLIENT_ID=your-scalekit-client-id 12 SCALEKIT_CLIENT_SECRET=your-scalekit-client-secret 13 GITHUB_CONNECTION_NAME=your-github-connection-name 14 15 # Optional — the app auto-detects its public URL from proxy headers. 16 # Only set this if you need to pin the callback origin explicitly. 17 # PUBLIC_BASE_URL=http://localhost:3000 ``` Generate `SESSION_SECRET` with: Terminal ```bash 1 openssl rand -hex 32 ``` ## 5. Add Scalekit auth helpers [Section titled “5. Add Scalekit auth helpers”](#5-add-scalekit-auth-helpers) The helper layer creates connected accounts, generates auth links, verifies the callback, and routes GitHub API calls through Scalekit’s connector. src/scalekit.ts ```typescript 1 import "dotenv/config"; 2 import { ScalekitClient } from "@scalekit-sdk/node"; 3 import type { JsonObject } from "@bufbuild/protobuf"; 4 5 let _scalekit: ScalekitClient | null = null; 6 7 function getScalekit(): ScalekitClient { 8 if (_scalekit) return _scalekit; 9 if (!process.env.SCALEKIT_ENVIRONMENT_URL || !process.env.SCALEKIT_CLIENT_ID || !process.env.SCALEKIT_CLIENT_SECRET) { 10 throw new Error("Missing SCALEKIT_ENVIRONMENT_URL, SCALEKIT_CLIENT_ID, or SCALEKIT_CLIENT_SECRET"); 11 } 12 _scalekit = new ScalekitClient( 13 process.env.SCALEKIT_ENVIRONMENT_URL, 14 process.env.SCALEKIT_CLIENT_ID, 15 process.env.SCALEKIT_CLIENT_SECRET, 16 ); 17 return _scalekit; 18 } 19 20 export const scalekit = new Proxy({} as ScalekitClient, { 21 get(_target, prop) { 22 return (getScalekit() as unknown as Record)[prop]; 23 }, 24 }); 25 26 const GITHUB_CONNECTION_NAME = process.env.GITHUB_CONNECTION_NAME; 27 if (!GITHUB_CONNECTION_NAME) { 28 throw new Error( 29 "GITHUB_CONNECTION_NAME is required. Copy the connection name from Scalekit Dashboard > Agent Auth > Connectors.", 30 ); 31 } 32 33 export async function getGitHubAuthLink( 34 identifier: string, 35 opts: { state: string; userVerifyUrl: string }, 36 ): Promise { 37 await scalekit.actions.getOrCreateConnectedAccount({ 38 connectionName: GITHUB_CONNECTION_NAME, 39 identifier, 40 }); 41 42 const res = await scalekit.actions.getAuthorizationLink({ 43 connectionName: GITHUB_CONNECTION_NAME, 44 identifier, 45 state: opts.state, 46 userVerifyUrl: opts.userVerifyUrl, 47 }); 48 49 if (!res.link) { 50 throw new Error( 51 `Scalekit did not return a GitHub authorization link for '${GITHUB_CONNECTION_NAME}' and identifier '${identifier}'`, 52 ); 53 } 54 55 return res.link; 56 } 57 58 export async function verifyUser(params: { 59 authRequestId: string; 60 identifier: string; 61 }): Promise { 62 await scalekit.actions.verifyConnectedAccountUser({ 63 authRequestId: params.authRequestId, 64 identifier: params.identifier, 65 }); 66 } 67 68 /** 69 * Check the connected account status via Scalekit API. 70 * Returns true when the account is active (OAuth complete and verified). 71 */ 72 export async function isAccountActive(identifier: string): Promise { 73 try { 74 const res = await scalekit.actions.getConnectedAccount({ 75 connectionName: GITHUB_CONNECTION_NAME, 76 identifier, 77 }); 78 // ConnectorStatus.ACTIVE === 1 79 return res.connectedAccount?.status === 1; 80 } catch { 81 return false; 82 } 83 } 84 85 export async function githubTool( 86 identifier: string, 87 toolName: string, 88 toolInput: Record, 89 ): Promise { 90 const res = await scalekit.actions.executeTool({ 91 toolName, 92 toolInput, 93 connector: GITHUB_CONNECTION_NAME, 94 identifier, 95 }); 96 97 return res.data ?? {}; 98 } 99 100 export async function githubRequest( 101 identifier: string, 102 path: string, 103 options: { 104 method?: string; 105 headers?: Record; 106 queryParams?: Record; 107 } = {}, 108 ) { 109 const res = await scalekit.actions.request({ 110 connectionName: GITHUB_CONNECTION_NAME, 111 identifier, 112 path, 113 method: options.method ?? "GET", 114 headers: options.headers, 115 queryParams: options.queryParams, 116 }); 117 118 return res.data; 119 } ``` Use the exact connector name The `connector` value in `executeTool` must be the full connection name from your own Scalekit environment, not the generic provider string `"github"`. ## 6. Bind the browser session to an opaque identifier [Section titled “6. Bind the browser session to an opaque identifier”](#6-bind-the-browser-session-to-an-opaque-identifier) The session layer is the security boundary for the whole app. Create `src/session.ts` and store three things: * a signed session cookie sent to the browser * an opaque `usr_...` identifier stored on the server * a one-time `state` value stored on the server while OAuth is in flight src/session.ts ```typescript 1 import { createHmac, randomBytes, timingSafeEqual } from "node:crypto"; 2 import type { Request, Response } from "express"; 3 4 const COOKIE_NAME = "sid"; 5 const STATE_TTL_MS = 10 * 60 * 1000; 6 7 interface SessionEntry { 8 identifier: string; 9 pendingState?: string; 10 pendingStateExpiresAt?: number; 11 connectedAt?: number; 12 } 13 14 const store = new Map(); 15 16 function getSecret(): string { 17 const secret = process.env.SESSION_SECRET; 18 if (!secret) { 19 throw new Error("SESSION_SECRET is required"); 20 } 21 return secret; 22 } 23 24 function sign(sessionId: string): string { 25 const mac = createHmac("sha256", getSecret()).update(sessionId).digest("base64url"); 26 return `${sessionId}.${mac}`; 27 } 28 29 function unsign(signed: string): string | null { 30 const dot = signed.lastIndexOf("."); 31 if (dot < 0) return null; 32 33 const sessionId = signed.slice(0, dot); 34 const mac = signed.slice(dot + 1); 35 const expected = createHmac("sha256", getSecret()).update(sessionId).digest("base64url"); 36 37 const expectedBuf = Buffer.from(expected); 38 const macBuf = Buffer.from(mac); 39 if (expectedBuf.length !== macBuf.length) return null; 40 41 return timingSafeEqual(expectedBuf, macBuf) ? sessionId : null; 42 } 43 44 export function requireSession(req: Request, res: Response) { 45 const cookies = Object.fromEntries( 46 (req.headers.cookie ?? "") 47 .split(";") 48 .flatMap((pair) => { 49 const eq = pair.indexOf("="); 50 if (eq < 0) return []; 51 try { 52 return [[pair.slice(0, eq).trim(), decodeURIComponent(pair.slice(eq + 1).trim())]]; 53 } catch { 54 return []; 55 } 56 }), 57 ); 58 59 const raw = cookies[COOKIE_NAME]; 60 let sessionId = raw ? unsign(raw) : null; 61 let entry = sessionId ? store.get(sessionId) ?? null : null; 62 63 if (!sessionId || !entry) { 64 sessionId = randomBytes(32).toString("base64url"); 65 entry = { identifier: "" }; 66 store.set(sessionId, entry); 67 } 68 69 // The cookie only carries a random opaque session id. HMAC signing is enough 70 // to detect tampering because the sensitive identifier stays server-side. 71 const protoHeader = req.get("x-forwarded-proto"); 72 const requestIsSecure = req.secure || protoHeader?.split(",")[0]?.trim() === "https"; 73 const secure = 74 process.env.NODE_ENV === "production" || 75 process.env.PUBLIC_BASE_URL?.startsWith("https://") === true || 76 requestIsSecure; 77 const parts = [ 78 `${COOKIE_NAME}=${sign(sessionId)}`, 79 "HttpOnly", 80 "SameSite=Lax", 81 "Path=/", 82 `Max-Age=${7 * 24 * 60 * 60}`, 83 ]; 84 if (secure) parts.push("Secure"); 85 res.setHeader("Set-Cookie", parts.join("; ")); 86 87 return { entry }; 88 } 89 90 export function mintIdentifier(entry: SessionEntry): string { 91 if (!entry.identifier) { 92 entry.identifier = `usr_${randomBytes(16).toString("hex")}`; 93 } 94 return entry.identifier; 95 } 96 97 export function setPendingState(entry: SessionEntry, state: string): void { 98 entry.pendingState = state; 99 entry.pendingStateExpiresAt = Date.now() + STATE_TTL_MS; 100 } 101 102 export function consumePendingState(entry: SessionEntry, incoming: string): boolean { 103 const stored = entry.pendingState; 104 const expiresAt = entry.pendingStateExpiresAt; 105 entry.pendingState = undefined; 106 entry.pendingStateExpiresAt = undefined; 107 108 if (!stored || !expiresAt || Date.now() > expiresAt) return false; 109 110 const storedBuf = Buffer.from(stored); 111 const incomingBuf = Buffer.from(incoming); 112 if (storedBuf.length !== incomingBuf.length) return false; 113 114 return timingSafeEqual(storedBuf, incomingBuf); 115 } 116 117 export function markConnected(entry: SessionEntry): void { 118 entry.connectedAt = Date.now(); 119 } 120 121 export function isConnected(entry: SessionEntry): boolean { 122 return entry.connectedAt !== undefined; 123 } ``` Never trust query params for identity Read the identifier from your own session store, not from the URL and not from the request body. The callback query string only proves that Scalekit completed an OAuth flow. Your server must decide which local user session owns that new connection. ## 7. Add the tasks [Section titled “7. Add the tasks”](#7-add-the-tasks) The task layer now accepts a server-side `identifier`, not a browser-supplied `userId`. src/tasks.ts ```typescript 1 import { task } from "@renderinc/sdk/workflows"; 2 import OpenAI from "openai"; 3 import { githubRequest, githubTool, getGitHubAuthLink } from "./scalekit.js"; 4 5 export interface PRSummaryInput { 6 identifier: string; 7 owner: string; 8 repo: string; 9 } 10 11 const fetchOpenPRs = task( 12 { name: "fetchOpenPRs", retry: { maxRetries: 3, waitDurationMs: 1000 } }, 13 async function fetchOpenPRs(identifier: string, owner: string, repo: string) { 14 const raw = await githubTool(identifier, "github_pull_requests_list", { 15 owner, 16 repo, 17 state: "open", 18 }); 19 20 const r = raw as Record; 21 const list = Array.isArray(raw) 22 ? raw 23 : Array.isArray(r.array) ? r.array 24 : Array.isArray(r.pull_requests) ? r.pull_requests 25 : Array.isArray(r.data) ? r.data 26 : null; 27 28 if (!list) { 29 throw new Error(`Unexpected response shape: ${JSON.stringify(raw).slice(0, 200)}`); 30 } 31 32 type PRItem = { number: number; title: string; comments: number; review_comments: number }; 33 return (list as PRItem[]) 34 .sort((a, b) => (b.comments + b.review_comments) - (a.comments + a.review_comments)) 35 .slice(0, 5); 36 }, 37 ); 38 39 const fetchPRDetails = task( 40 { name: "fetchPRDetails", retry: { maxRetries: 3, waitDurationMs: 1000 } }, 41 async function fetchPRDetails(identifier: string, owner: string, repo: string, prNumber: number) { 42 const [diffRaw, commentsRaw] = await Promise.all([ 43 githubRequest(identifier, `/repos/${owner}/${repo}/pulls/${prNumber}`, { 44 headers: { Accept: "application/vnd.github.diff" }, 45 }), 46 githubRequest(identifier, `/repos/${owner}/${repo}/issues/${prNumber}/comments`), 47 ]); 48 49 const diff = typeof diffRaw === "string" ? diffRaw.slice(0, 3000) : ""; 50 const comments = Array.isArray(commentsRaw) ? commentsRaw : []; 51 52 return { diff, comments }; 53 }, 54 ); 55 56 export const setupGitHubAuthTask = task( 57 { name: "setupGitHubAuth" }, 58 async function setupGitHubAuth(params: { 59 identifier: string; 60 state: string; 61 userVerifyUrl: string; 62 }) { 63 const link = await getGitHubAuthLink(params.identifier, { 64 state: params.state, 65 userVerifyUrl: params.userVerifyUrl, 66 }); 67 68 return { authLink: link }; 69 }, 70 ); 71 72 // ---- LLM summary ---- 73 74 function createOpenAIClient(): OpenAI { 75 const apiKey = process.env.OPENAI_API_KEY; 76 if (!apiKey) throw new Error("OPENAI_API_KEY not set"); 77 return new OpenAI({ 78 apiKey, 79 ...(process.env.OPENAI_BASE_URL && { baseURL: process.env.OPENAI_BASE_URL }), 80 }); 81 } 82 83 const generateSummary = task( 84 { name: "generateSummary", retry: { maxRetries: 3, waitDurationMs: 2000 } }, 85 async function generateSummary( 86 prs: { number: number; title: string; diff: string; comments: { body?: string }[] }[], 87 owner: string, 88 repo: string, 89 ): Promise { 90 if (prs.length === 0) return "No open pull requests found in this repository."; 91 92 const client = createOpenAIClient(); 93 const prBlocks = prs 94 .map((pr) => { 95 const bodies = pr.comments.slice(0, 5).map((c) => `> ${(c.body ?? "").slice(0, 300)}`).join("\n"); 96 return `PR #${pr.number} — ${pr.title}\n${bodies || "No comments."}\nDiff:\n${pr.diff || "(not available)"}`; 97 }) 98 .join("\n\n---\n\n"); 99 100 const response = await client.chat.completions.create({ 101 model: process.env.OPENAI_MODEL ?? "gpt-4.1-mini", 102 messages: [ 103 { 104 role: "system", 105 content: 106 "Summarize each PR in one paragraph (3-4 sentences) for a team lead. " + 107 "Cover what it does, how much discussion happened, and whether it looks close to merging.", 108 }, 109 { role: "user", content: `Repository: ${owner}/${repo}\n\n${prBlocks}` }, 110 ], 111 }); 112 113 return response.choices[0].message.content ?? "(no summary generated)"; 114 }, 115 ); 116 117 // ---- Root task ---- 118 119 export const summarizePRsTask = task( 120 { name: "summarizePRs", timeoutSeconds: 120 }, 121 async function summarizePRs(input: PRSummaryInput) { 122 const { identifier, owner, repo } = input; 123 const topPRs = await fetchOpenPRs(identifier, owner, repo); 124 125 if (topPRs.length === 0) { 126 return { repository: `${owner}/${repo}`, prsAnalyzed: [] as string[], summary: "No open pull requests found." }; 127 } 128 129 const details = await Promise.all( 130 topPRs.map((pr) => fetchPRDetails(identifier, owner, repo, pr.number)), 131 ); 132 133 const prsForSummary = topPRs.map((pr, i) => ({ 134 number: pr.number, 135 title: pr.title, 136 diff: details[i].diff, 137 comments: details[i].comments as { body?: string }[], 138 })); 139 140 const summary = await generateSummary(prsForSummary, owner, repo); 141 142 return { 143 repository: `${owner}/${repo}`, 144 prsAnalyzed: topPRs.map((p) => `#${p.number}: ${p.title}`), 145 summary, 146 }; 147 }, 148 ); ``` ## 8. Wire the HTTP server [Section titled “8. Wire the HTTP server”](#8-wire-the-http-server) The HTTP server owns the secure flow. It issues the session cookie, starts the GitHub auth flow, validates the callback, and blocks summary requests until the session is connected. src/server.ts ```typescript 1 import crypto from "node:crypto"; 2 import express from "express"; 3 import { setupGitHubAuthTask, summarizePRsTask } from "./tasks.js"; 4 import { isAccountActive, verifyUser } from "./scalekit.js"; 5 import { 6 consumePendingState, 7 isConnected, 8 markConnected, 9 mintIdentifier, 10 requireSession, 11 setPendingState, 12 } from "./session.js"; 13 import { renderHomePage, renderAuthCompletePage } from "./views.js"; 14 import type { Request } from "express"; 15 16 function getConfiguredPublicBaseUrl(): string | null { 17 const value = process.env.PUBLIC_BASE_URL; 18 return value ? value.replace(/\/$/, "") : null; 19 } 20 21 function getRequestOrigin(req: Request): string { 22 const configured = getConfiguredPublicBaseUrl(); 23 if (configured) return configured; 24 25 const protoHeader = req.get("x-forwarded-proto"); 26 const proto = protoHeader?.split(",")[0]?.trim() || req.protocol || "http"; 27 const host = req.get("x-forwarded-host") || req.get("host"); 28 if (!host) { 29 throw new Error("Could not determine the public origin for this request"); 30 } 31 return `${proto}://${host}`; 32 } 33 34 export function startServer(): void { 35 const app = express(); 36 app.set("trust proxy", true); 37 app.use(express.json()); 38 39 app.get("/", (req, res) => { 40 const { entry } = requireSession(req, res); 41 res.type("html").send(renderHomePage({ connected: isConnected(entry) })); 42 }); 43 44 // Polled by the original tab while the OAuth tab is open. 45 // Checks the in-memory session first, then queries the Scalekit API 46 // to detect when the connected account becomes ACTIVE. 47 app.get("/api/auth/status", async (req, res) => { 48 const { entry } = requireSession(req, res); 49 if (isConnected(entry)) { 50 res.json({ connected: true }); 51 return; 52 } 53 if (entry.identifier && await isAccountActive(entry.identifier)) { 54 markConnected(entry); 55 res.json({ connected: true }); 56 return; 57 } 58 res.json({ connected: false }); 59 }); 60 61 app.post("/api/auth", async (req, res) => { 62 const { entry } = requireSession(req, res); 63 const identifier = mintIdentifier(entry); 64 65 const state = crypto.randomUUID(); 66 setPendingState(entry, state); 67 68 const result = await setupGitHubAuthTask({ 69 identifier, 70 state, 71 userVerifyUrl: `${getRequestOrigin(req)}/user/verify`, 72 }); 73 74 res.json({ authLink: result.authLink }); 75 }); 76 77 // Callback for custom user verification mode. When Scalekit is 78 // configured in "Scalekit users only" mode, this route may not fire — 79 // the /api/auth/status polling handles that case via the Scalekit API. 80 app.get("/user/verify", async (req, res) => { 81 const { auth_request_id, state } = req.query as Record; 82 if (!auth_request_id || !state) { 83 res.status(400).send("Missing auth_request_id or state"); 84 return; 85 } 86 87 const { entry } = requireSession(req, res); 88 if (!entry.identifier) { 89 res.status(400).send("No pending authorization for this session"); 90 return; 91 } 92 93 if (!consumePendingState(entry, state)) { 94 res.status(400).send("Invalid or expired state"); 95 return; 96 } 97 98 await verifyUser({ 99 authRequestId: auth_request_id, 100 identifier: entry.identifier, 101 }); 102 103 markConnected(entry); 104 // This handler runs in the OAuth tab. Render a minimal page 105 // telling the user to close it — the original tab is polling 106 // /api/auth/status and will auto-reload. 107 res.type("html").send(renderAuthCompletePage()); 108 }); 109 110 app.post("/api/summarize", async (req, res) => { 111 const { entry } = requireSession(req, res); 112 if (!isConnected(entry)) { 113 res.status(401).json({ error: "Connect your GitHub account first" }); 114 return; 115 } 116 117 // The UI sends { repository: "https://github.com/owner/repo" } or "owner/repo". 118 // Parse the string into separate owner and repo values. 119 const { repository } = req.body as { repository?: string }; 120 if (!repository) { 121 res.status(400).json({ error: "Provide a GitHub repository URL or owner/repo name." }); 122 return; 123 } 124 125 let owner: string | undefined; 126 let repo: string | undefined; 127 try { 128 const url = new URL(repository); 129 const segments = url.pathname.split("/").filter(Boolean); 130 owner = segments[0]; 131 repo = segments[1]?.replace(/\.git$/, ""); 132 } catch { 133 const parts = repository.split("/"); 134 owner = parts[0]; 135 repo = parts[1]?.replace(/\.git$/, ""); 136 } 137 138 if (!owner || !repo) { 139 res.status(400).json({ error: "Provide a GitHub repository URL or owner/repo name." }); 140 return; 141 } 142 143 const result = await summarizePRsTask({ identifier: entry.identifier, owner, repo }); 144 res.json(result); 145 }); 146 } ``` ## 9. Render the browser UI [Section titled “9. Render the browser UI”](#9-render-the-browser-ui) The UI only asks for a repository. It does not ask for a user identifier. After a successful connection, the page auto-reloads and shows a connected banner. The key change from a naive implementation: `connectGitHub()` opens the auth link in a **new tab** instead of navigating the current page. This keeps the app intact even if the OAuth redirect chain doesn’t return cleanly. The original tab polls `/api/auth/status` and auto-reloads when the Scalekit API reports the account as `ACTIVE`. src/views.ts ```typescript 1 export function renderAuthCompletePage(): string { 2 return ` 3 4 5

✓ GitHub connected

You can close this tab and return to the app. The original page will update automatically.

9 10 `; 11 } 12 13 export function renderHomePage({ connected }: { connected: boolean }): string { 14 const connectedBanner = connected 15 ? `` 16 : ``; 17 const authButtonLabel = connected ? "Reconnect GitHub" : "Connect GitHub"; 18 19 return ` 20 21 22 ${connectedBanner} 23 24

25 26 27

28 88 89 `; 90 } ``` ## 10. Run locally [Section titled “10. Run locally”](#10-run-locally) 1. Copy `.env.example` to `.env` and fill in your values. 2. Run `npm install`. 3. Run `npm run dev`. 4. Open `http://localhost:3000`. 5. Click **Connect GitHub**. A new tab opens for the GitHub OAuth flow. 6. Complete the OAuth consent in the new tab. 7. The new tab shows “GitHub connected — you can close this tab” (in custom verification mode) or a Scalekit success page (in Scalekit-users-only mode). 8. The original tab auto-detects the connection and reloads, showing a **GitHub connected** banner. 9. Enter a repository URL or `owner/repo`, then generate a summary. Public repositories work with any connected GitHub account. Private repositories only work if the connected account has access. ## 11. Deploy to Render [Section titled “11. Deploy to Render”](#11-deploy-to-render) Render deploys the app as a web service from `render.yaml`. Set these environment variables in Render: | Variable | Required | Notes | | -------------------------- | -------- | --------------------------------------------------------------------- | | `SCALEKIT_ENVIRONMENT_URL` | Yes | From Scalekit dashboard → Developers → API Credentials | | `SCALEKIT_CLIENT_ID` | Yes | Same location | | `SCALEKIT_CLIENT_SECRET` | Yes | Same location | | `GITHUB_CONNECTION_NAME` | Yes | From AgentKit → Connectors | | `OPENAI_API_KEY` | Yes | OpenAI key or proxy token | | `OPENAI_BASE_URL` | No | Leave empty for OpenAI direct. Set for LiteLLM/Azure/Ollama. | | `OPENAI_MODEL` | No | Default: `gpt-4.1-mini` | | `SESSION_SECRET` | Auto | `render.yaml` auto-generates this | | `PUBLIC_BASE_URL` | No | Auto-detected from proxy headers. Only needed behind a custom domain. | After deploying, configure user verification in the Scalekit dashboard ([step 2](#2-configure-user-verification-required)). The app will not complete the GitHub connection flow without this. ## Production notes [Section titled “Production notes”](#production-notes) * **User verification mode**: Switch to **Custom user verification** in the Scalekit dashboard before going to production. This ensures your backend confirms which session owns each new connection. * **Shared session store**: The sample stores session data in memory. Use Redis or a database-backed shared store in production. * **Short-lived OAuth state**: The sample expires the pending `state` after 10 minutes and consumes it after a single callback. * **Session-bound identifier**: The browser never chooses the identifier that Scalekit uses to look up the connected account. * **Connector-backed GitHub requests**: The sample routes both PR listing and PR detail fetches through Scalekit so the connected user’s token is used consistently. ## Next steps [Section titled “Next steps”](#next-steps) * Read [user verification for connected accounts](/agentkit/user-verification/) for the full verification model and additional examples. * Read [authorize a user](/agentkit/tools/authorize/) for the status-polling pattern used to detect when a connected account becomes `ACTIVE`. * Open the [render-ai-agent-deploykit](https://github.com/scalekit-developers/render-ai-agent-deploykit) repository to compare the full implementation against the snippets in this cookbook. --- # DOCUMENT BOUNDARY --- # Build an agent that books meetings and drafts emails > Connect a Python agent to Google Calendar and Gmail via Scalekit to find free slots, book meetings, and draft follow-up emails. Scheduling a meeting sounds simple: find a free slot, create an event, send a confirmation. But in an agent, each of those steps crosses a tool boundary — and each tool requires its own OAuth token. Without a managed auth layer, you end up writing token-fetching, refresh logic, and error handling three times over before you write a single line of scheduling logic. This cookbook solves that by using Scalekit to own the OAuth lifecycle for each connector, so your agent can focus on the workflow itself. This is a Python recipe for agents that call two or more external APIs on behalf of a user. If you’re using a service account rather than user-delegated OAuth, or building in JavaScript, the pattern is the same but the source differs — see the `javascript/` track in [agent-auth-examples](https://github.com/scalekit-developers/agent-auth-examples). The complete Python source used here is `python/meeting_scheduler_agent.py` in that repo. **The core problems this solves:** * **One token per connector** — Google Calendar and Gmail use separate OAuth scopes and separate access tokens. Your agent must manage both independently. * **First-run authorization is blocking** — If the user has not yet authorized a connector, your agent cannot proceed until they complete the browser OAuth flow. * **Token expiry is silent** — A token that worked yesterday fails today, and the failure looks identical to a permissions error. * **Chaining tool outputs is fragile** — The event link from the Calendar API needs to appear in the Gmail draft. If the Calendar call fails mid-workflow, the draft gets a broken link or never gets created. Scalekit exposes a `connected_accounts` abstraction that maps a user ID to an authorized OAuth session per connector. When your agent calls `get_or_create_connected_account`, Scalekit either returns an existing active account with a valid token or creates a new one and returns an authorization URL. Once the user authorizes, `get_connected_account` returns the token. From that point, Scalekit handles refresh automatically. This means your agent’s authorization step is a single function regardless of which connector you’re targeting. The rest of the code — Calendar queries, event creation, Gmail drafts — is plain HTTP with the token Scalekit provides. 1. **Set up the environment** Create a `.env` file at the project root with your Scalekit credentials: ```bash 1 SCALEKIT_ENVIRONMENT_URL=https://your-env.scalekit.com 2 SCALEKIT_CLIENT_ID=your-client-id 3 SCALEKIT_CLIENT_SECRET=your-client-secret ``` Install dependencies: ```bash 1 pip install scalekit-sdk python-dotenv requests ``` In the Scalekit Dashboard, create two connections for your environment: * `googlecalendar` — Google Calendar OAuth connection * `gmail` — Gmail OAuth connection The script references these names literally. The names must match exactly. 2. **Initialize the Scalekit client** meeting\_scheduler\_agent.py ```python 1 import os 2 import base64 3 from datetime import datetime, timezone, timedelta 4 from email.mime.text import MIMEText 5 6 import requests 7 from dotenv import load_dotenv 8 from scalekit import ScalekitClient 9 10 load_dotenv() 11 12 # Never hard-code credentials — they would be exposed in source control 13 # and CI logs. Pull them from environment variables instead. 14 scalekit_client = ScalekitClient( 15 environment_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"), 16 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 17 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 18 ) 19 20 actions = scalekit_client.actions 21 22 # Replace with a real user identifier from your application's session 23 USER_ID = "user_123" 24 ATTENDEE_EMAIL = "attendee@example.com" 25 MEETING_TITLE = "Quick Sync" 26 DURATION_MINUTES = 60 27 SEARCH_DAYS = 3 28 WORK_START_HOUR = 9 # UTC 29 WORK_END_HOUR = 17 # UTC ``` `scalekit_client.actions` is the entry point for all connected-account operations. Initialize it once and pass `actions` to the functions below. 3. **Authorize each connector** The `authorize` function handles the first-run prompt and returns a valid access token: ```python 1 def authorize(connector: str) -> str: 2 """Ensure the user has an active connected account and return its access token. 3 4 On first run, this prints an authorization URL and waits for the user 5 to complete the browser OAuth flow before continuing. 6 """ 7 account = actions.get_or_create_connected_account(connector, USER_ID) 8 9 if account.status != "active": 10 auth_link = actions.get_authorization_link(connector, USER_ID) 11 print(f"\nOpen this link to authorize {connector}:\n{auth_link}\n") 12 input("Press Enter after completing authorization in your browser…") 13 account = actions.get_connected_account(connector, USER_ID) 14 15 return account.authorization_details["oauth_token"]["access_token"] ``` Call this once per connector before any API calls: ```python 1 calendar_token = authorize("googlecalendar") 2 gmail_token = authorize("gmail") ``` After the first successful authorization, `get_or_create_connected_account` returns `status == "active"` on subsequent runs and the `if` block is skipped. Scalekit refreshes expired tokens automatically. 4. **Query calendar availability** With a valid Calendar token, query the `freeBusy` endpoint to get the user’s busy intervals: ```python 1 def get_busy_slots(token: str) -> list[dict]: 2 """Fetch busy intervals for the user's primary calendar.""" 3 now = datetime.now(timezone.utc) 4 window_end = now + timedelta(days=SEARCH_DAYS) 5 6 response = requests.post( 7 "https://www.googleapis.com/calendar/v3/freeBusy", 8 headers={"Authorization": f"Bearer {token}"}, 9 json={ 10 "timeMin": now.isoformat(), 11 "timeMax": window_end.isoformat(), 12 "items": [{"id": "primary"}], 13 }, 14 ) 15 response.raise_for_status() 16 return response.json()["calendars"]["primary"]["busy"] ``` `raise_for_status()` converts 4xx and 5xx responses into exceptions, so the caller sees a clear error rather than a silent wrong result. The `busy` list contains `{"start": "...", "end": "..."}` dicts in ISO 8601 format. 5. **Find the first open slot** Walk forward in one-hour increments from now and return the first candidate that falls within working hours and does not overlap a busy interval: ```python 1 def find_free_slot(busy_slots: list[dict]) -> tuple[datetime, datetime] | None: 2 """Return the first open one-hour slot during working hours in UTC. 3 4 Returns None if no slot is available in the search window. 5 """ 6 now = datetime.now(timezone.utc) 7 # Round up to the next whole hour so the candidate is always in the future 8 candidate = now.replace(minute=0, second=0, microsecond=0) + timedelta(hours=1) 9 window_end = now + timedelta(days=SEARCH_DAYS) 10 11 while candidate < window_end: 12 slot_end = candidate + timedelta(minutes=DURATION_MINUTES) 13 14 if WORK_START_HOUR <= candidate.hour < WORK_END_HOUR: 15 overlap = any( 16 candidate < datetime.fromisoformat(b["end"]) 17 and slot_end > datetime.fromisoformat(b["start"]) 18 for b in busy_slots 19 ) 20 if not overlap: 21 return candidate, slot_end 22 23 candidate += timedelta(hours=1) 24 25 return None ``` This is a useful first-draft strategy: simple, readable, easy to debug. Its limits are real (one-hour granularity, UTC-only, primary calendar only) and addressed in [Production notes](#production-notes) below. 6. **Create the calendar event** Post the event to the Google Calendar API and return its HTML link, which you’ll include in the email draft: ```python 1 def create_event(token: str, start: datetime, end: datetime) -> str: 2 """Create a calendar event and return its HTML link.""" 3 response = requests.post( 4 "https://www.googleapis.com/calendar/v3/calendars/primary/events", 5 headers={"Authorization": f"Bearer {token}"}, 6 json={ 7 "summary": MEETING_TITLE, 8 "description": "Scheduled by agent", 9 "start": {"dateTime": start.isoformat(), "timeZone": "UTC"}, 10 "end": {"dateTime": end.isoformat(), "timeZone": "UTC"}, 11 "attendees": [{"email": ATTENDEE_EMAIL}], 12 }, 13 ) 14 response.raise_for_status() 15 return response.json()["htmlLink"] ``` The `htmlLink` in the response is the calendar event URL. Google also sends an invitation email to each attendee automatically when the event is created; the draft you create in the next step is a separate follow-up, not the invitation itself. 7. **Draft the confirmation email** Build the email body, base64-encode it, and post it to Gmail’s drafts endpoint: ```python 1 def create_draft(token: str, event_link: str, start: datetime) -> None: 2 """Create a Gmail draft with the meeting details.""" 3 body = ( 4 f"Hi,\n\n" 5 f"I've scheduled '{MEETING_TITLE}' for " 6 f"{start.strftime('%A, %B %d at %H:%M UTC')} ({DURATION_MINUTES} min).\n\n" 7 f"Calendar link: {event_link}\n\n" 8 f"Looking forward to it!" 9 ) 10 11 message = MIMEText(body) 12 message["to"] = ATTENDEE_EMAIL 13 message["subject"] = f"Invitation: {MEETING_TITLE}" 14 15 # Gmail's API requires the raw RFC 2822 message encoded as URL-safe base64 16 raw = base64.urlsafe_b64encode(message.as_bytes()).decode() 17 18 response = requests.post( 19 "https://gmail.googleapis.com/gmail/v1/users/me/drafts", 20 headers={"Authorization": f"Bearer {token}"}, 21 json={"message": {"raw": raw}}, 22 ) 23 response.raise_for_status() 24 print("Draft created in Gmail.") ``` The script creates a draft, not a sent message. The user reviews it before sending. This is the right default for an agent — it takes the action but keeps a human in the loop for outbound communication. 8. **Wire it together** ```python 1 def main() -> None: 2 print("Authorizing Google Calendar…") 3 calendar_token = authorize("googlecalendar") 4 5 print("Authorizing Gmail…") 6 gmail_token = authorize("gmail") 7 8 print("Checking calendar availability…") 9 busy_slots = get_busy_slots(calendar_token) 10 11 slot = find_free_slot(busy_slots) 12 if not slot: 13 print(f"No free slot found in the next {SEARCH_DAYS} days.") 14 return 15 16 start, end = slot 17 print(f"Found slot: {start.strftime('%A %B %d, %H:%M')} UTC") 18 19 print("Creating calendar event…") 20 event_link = create_event(calendar_token, start, end) 21 print(f"Event created: {event_link}") 22 23 print("Creating Gmail draft…") 24 create_draft(gmail_token, event_link, start) 25 26 27 if __name__ == "__main__": 28 main() ``` ## Testing [Section titled “Testing”](#testing) Run the agent from the command line: ```bash 1 python meeting_scheduler_agent.py ``` On first run, you should see two authorization prompts in sequence: ```plaintext 1 Authorizing Google Calendar… 2 3 Open this link to authorize googlecalendar: 4 https://accounts.google.com/o/oauth2/auth?... 5 6 Press Enter after completing authorization in your browser… 7 8 Authorizing Gmail… 9 10 Open this link to authorize gmail: 11 https://accounts.google.com/o/oauth2/auth?... 12 13 Press Enter after completing authorization in your browser… 14 15 Checking calendar availability… 16 Found slot: Wednesday March 11, 10:00 UTC 17 Creating calendar event… 18 Event created: https://calendar.google.com/calendar/event?eid=... 19 Creating Gmail draft… 20 Draft created in Gmail. ``` On subsequent runs, the authorization prompts are skipped and the agent goes straight to availability checking. Verify the results: 1. Open Google Calendar — you should see the event on the chosen date 2. Open Gmail — you should see a draft in the Drafts folder with the event link ## Common mistakes [Section titled “Common mistakes”](#common-mistakes) * **Connection name mismatch** — If you name the Scalekit connection `google-calendar` instead of `googlecalendar`, `get_or_create_connected_account` returns an error. The name in the Dashboard must match the string you pass to `authorize()` exactly. * **Missing OAuth scopes** — If you see a `403 Forbidden` when calling the Calendar or Gmail API, the OAuth app in Google Cloud Console is missing the required scopes. Calendar needs `https://www.googleapis.com/auth/calendar` and Gmail needs `https://www.googleapis.com/auth/gmail.compose`. * **`raise_for_status()` swallowing context** — The default exception message from `requests` truncates the response body. In development, add `print(response.text)` before `raise_for_status()` to see the full error from Google. * **UTC times without timezone info** — Passing a naive `datetime` (without `timezone.utc`) to `isoformat()` produces a string without a `Z` suffix. Google Calendar rejects this with a `400` error. Always construct datetimes with `timezone.utc`. * **`USER_ID` not matching your session** — The script uses a hardcoded `"user_123"`. In production, replace this with the actual user ID from your application’s session. A mismatch means the connected account query returns the wrong user’s tokens. ## Production notes [Section titled “Production notes”](#production-notes) **Timezone handling** — The working-hours check (`WORK_START_HOUR`, `WORK_END_HOUR`) is UTC-only. In production, convert the user’s local timezone and the attendee’s timezone before searching. The `zoneinfo` module (Python 3.9+) handles this without third-party dependencies. **Slot granularity** — The one-hour increment misses 30- and 15-minute openings. For real scheduling, use the busy intervals directly to calculate the gaps between events, then filter by minimum duration. **Multiple calendars** — The `freeBusy` query checks only `primary`. Users who manage work and personal calendars separately will show false availability. Expand the `items` list to include all calendars the user has shared access to. **Draft vs send** — Creating a draft is safer for a first deployment. When you’re confident in the agent’s output quality, switch the Gmail endpoint from `/drafts` to `/messages/send` to make the agent fully autonomous. Add a confirmation step before making this change. **Error recovery** — If `create_event` succeeds but `create_draft` fails, you have an orphaned event with no follow-up email. In production, wrap the two calls in a compensation pattern: track the event ID and delete it if the draft creation fails. **Rate limits** — Google Calendar and Gmail both have per-user quotas. If your agent runs frequently for the same user, add exponential backoff around the `requests.post` calls. ## Next steps [Section titled “Next steps”](#next-steps) * **Add user input** — Replace the hardcoded `ATTENDEE_EMAIL`, `MEETING_TITLE`, and `DURATION_MINUTES` with parameters parsed from natural language using an LLM tool call. * **Build the JavaScript equivalent** — The `agent-auth-examples` repo includes a JavaScript track. Compare the two implementations to see where the patterns converge and where they differ. * **Handle re-authorization** — If a user revokes access, `get_connected_account` returns an inactive account. Add a re-authorization path to recover gracefully instead of crashing. * **Explore other connectors** — The same `authorize()` pattern works for any Scalekit-supported connector: Slack, Notion, Jira. Swap the connector name and replace the Google API calls with the target service’s API. * **Review the Scalekit agent auth quickstart** — For a broader overview of the connected-accounts model, see the [agent auth quickstart](/agentkit/quickstart). --- # DOCUMENT BOUNDARY --- # Enforce seat limits with SCIM provisioning > Block over-quota user creation and alert admins when SCIM pushes users beyond your plan seat limit. SCIM (System for Cross-domain Identity Management) provisioning runs unsupervised. When a customer’s HR system pushes user #51 to a 50-seat plan, your application will create that user unless you explicitly block it. Scalekit delivers the provisioning events; your application decides whether to act on them. This cookbook shows the two-event pattern that keeps your seat count accurate and tells admins when they need to upgrade their plan. ## SCIM does not enforce seat limits — your app must [Section titled “SCIM does not enforce seat limits — your app must”](#scim-does-not-enforce-seat-limits--your-app-must) Scalekit translates IdP-specific provisioning protocols into a consistent set of webhook events. It does not know your billing model, your seat limits, or which organizations have room for more users. That logic lives in your application. When a user is added in the IdP, Scalekit fires `organization.directory.user_created`. When a user is removed or deactivated, Scalekit fires `organization.directory.user_deleted`. Your webhook handler is the gate between those events and your user table. ## Two webhook events carry the full user lifecycle [Section titled “Two webhook events carry the full user lifecycle”](#two-webhook-events-carry-the-full-user-lifecycle) Both events include the `organization_id`, which lets you look up the seat limit for that specific customer. | Event | When it fires | What to do | | ------------------------------------- | --------------------------------- | ----------------------------------------------------- | | `organization.directory.user_created` | IdP adds or activates a user | Check count — create user or block and notify | | `organization.directory.user_deleted` | IdP removes or deactivates a user | Decrement count — clear any blocked-provisioning flag | ## Track a user count per organization in your database [Section titled “Track a user count per organization in your database”](#track-a-user-count-per-organization-in-your-database) Add a table that stores the provisioned user count and seat limit for each organization. The examples below use plain SQL — translate to your ORM if preferred. db/schema.sql ```sql 1 CREATE TABLE org_seat_usage ( 2 org_id TEXT PRIMARY KEY, 3 seat_limit INTEGER NOT NULL, 4 used_seats INTEGER NOT NULL DEFAULT 0 5 ); ``` Seed this table when you onboard a new customer. Update `seat_limit` whenever the customer upgrades or downgrades their plan. ## Block creation when the count reaches the limit [Section titled “Block creation when the count reaches the limit”](#block-creation-when-the-count-reaches-the-limit) The `user_created` handler increments the seat counter and creates the user only when there is room. Always return `200` to Scalekit — returning an error code causes Scalekit to retry delivery, which does not help when the block is intentional. Verify webhook signatures before processing Always verify that events come from Scalekit before acting on them. An unverified endpoint that mutates your database can be triggered by forged requests. See the [SCIM provisioning quickstart](/directory/scim/quickstart/) for how to verify signatures using the Scalekit SDK. * Node.js webhook-handler.ts ```ts 1 import express from 'express' 2 3 const app = express() 4 app.use(express.json()) 5 6 app.post('/webhooks/scalekit', async (req, res) => { 7 const event = req.body 8 9 if (event.type === 'organization.directory.user_created') { 10 const orgId = event.organization_id 11 const directoryUser = event.data 12 let seatLimitReached = false 13 14 // Run the check and insert in a single transaction. 15 // FOR UPDATE inside the transaction holds the lock until commit. 16 await db.transaction(async (tx) => { 17 const usage = await tx.queryOne( 18 'SELECT seat_limit, used_seats FROM org_seat_usage WHERE org_id = $1 FOR UPDATE', 19 [orgId] 20 ) 21 22 if (!usage || usage.used_seats >= usage.seat_limit) { 23 seatLimitReached = true 24 return 25 } 26 27 await tx.query( 28 'INSERT INTO users (id, org_id, email, name) VALUES ($1, $2, $3, $4)', 29 [directoryUser.id, orgId, directoryUser.email, directoryUser.name] 30 ) 31 await tx.query( 32 'UPDATE org_seat_usage SET used_seats = used_seats + 1 WHERE org_id = $1', 33 [orgId] 34 ) 35 }) 36 37 if (seatLimitReached) { 38 // Seat limit reached — skip user creation and alert the admin. 39 await notifyAdminSeatLimitReached(orgId) 40 } 41 } 42 43 // Return 200 so Scalekit does not retry this event. 44 res.sendStatus(200) 45 }) ``` * Python webhook\_handler.py ```python 1 from flask import Flask, request 2 3 app = Flask(__name__) 4 5 @app.route('/webhooks/scalekit', methods=['POST']) 6 def handle_webhook(): 7 event = request.get_json() 8 9 if event.get('type') == 'organization.directory.user_created': 10 org_id = event['organization_id'] 11 directory_user = event['data'] 12 seat_limit_reached = False 13 14 # Run the check and insert in a single transaction. 15 # FOR UPDATE inside the transaction holds the lock until commit. 16 with db.transaction() as tx: 17 usage = tx.query_one( 18 'SELECT seat_limit, used_seats FROM org_seat_usage ' 19 'WHERE org_id = %s FOR UPDATE', 20 (org_id,) 21 ) 22 23 if not usage or usage['used_seats'] >= usage['seat_limit']: 24 seat_limit_reached = True 25 else: 26 tx.execute( 27 'INSERT INTO users (id, org_id, email, name) VALUES (%s, %s, %s, %s)', 28 (directory_user['id'], org_id, 29 directory_user['email'], directory_user['name']) 30 ) 31 tx.execute( 32 'UPDATE org_seat_usage SET used_seats = used_seats + 1 ' 33 'WHERE org_id = %s', 34 (org_id,) 35 ) 36 37 if seat_limit_reached: 38 # Seat limit reached — skip user creation and alert the admin. 39 notify_admin_seat_limit_reached(org_id) 40 41 # Return 200 so Scalekit does not retry this event. 42 return '', 200 ``` * Go webhook\_handler.go ```go 1 package main 2 3 import ( 4 "encoding/json" 5 "net/http" 6 ) 7 8 func webhookHandler(w http.ResponseWriter, r *http.Request) { 9 var event map[string]interface{} 10 if err := json.NewDecoder(r.Body).Decode(&event); err != nil { 11 http.Error(w, "bad request", http.StatusBadRequest) 12 return 13 } 14 15 if event["type"] == "organization.directory.user_created" { 16 orgID := event["organization_id"].(string) 17 data := event["data"].(map[string]interface{}) 18 seatLimitReached := false 19 20 // Run the check and insert in a single transaction. 21 // FOR UPDATE inside the transaction holds the lock until commit. 22 tx, _ := db.Begin() 23 var seatLimit, usedSeats int 24 err := tx.QueryRow( 25 "SELECT seat_limit, used_seats FROM org_seat_usage WHERE org_id = $1 FOR UPDATE", 26 orgID, 27 ).Scan(&seatLimit, &usedSeats) 28 29 if err != nil || usedSeats >= seatLimit { 30 seatLimitReached = true 31 tx.Rollback() 32 } else { 33 tx.Exec( 34 "INSERT INTO users (id, org_id, email, name) VALUES ($1, $2, $3, $4)", 35 data["id"], orgID, data["email"], data["name"], 36 ) 37 tx.Exec( 38 "UPDATE org_seat_usage SET used_seats = used_seats + 1 WHERE org_id = $1", 39 orgID, 40 ) 41 tx.Commit() 42 } 43 44 if seatLimitReached { 45 // Seat limit reached — skip user creation and alert the admin. 46 notifyAdminSeatLimitReached(orgID) 47 } 48 } 49 50 // Return 200 so Scalekit does not retry this event. 51 w.WriteHeader(http.StatusOK) 52 } ``` * Java WebhookController.java ```java 1 import org.springframework.web.bind.annotation.*; 2 import java.util.Map; 3 import java.util.concurrent.atomic.AtomicBoolean; 4 5 @RestController 6 public class WebhookController { 7 8 @PostMapping("/webhooks/scalekit") 9 public ResponseEntity handleWebhook(@RequestBody Map event) { 10 if ("organization.directory.user_created".equals(event.get("type"))) { 11 String orgId = (String) event.get("organization_id"); 12 Map directoryUser = (Map) event.get("data"); 13 AtomicBoolean seatLimitReached = new AtomicBoolean(false); 14 15 // Run the check and insert in a single transaction. 16 // FOR UPDATE inside the transaction holds the lock until commit. 17 transactionTemplate.execute(status -> { 18 OrgSeatUsage usage = db.queryForObject( 19 "SELECT seat_limit, used_seats FROM org_seat_usage WHERE org_id = ? FOR UPDATE", 20 OrgSeatUsage.class, orgId 21 ); 22 23 if (usage == null || usage.getUsedSeats() >= usage.getSeatLimit()) { 24 seatLimitReached.set(true); 25 return null; 26 } 27 28 db.update( 29 "INSERT INTO users (id, org_id, email, name) VALUES (?, ?, ?, ?)", 30 directoryUser.get("id"), orgId, 31 directoryUser.get("email"), directoryUser.get("name") 32 ); 33 db.update( 34 "UPDATE org_seat_usage SET used_seats = used_seats + 1 WHERE org_id = ?", 35 orgId 36 ); 37 return null; 38 }); 39 40 if (seatLimitReached.get()) { 41 // Seat limit reached — skip user creation and alert the admin. 42 notifyAdminSeatLimitReached(orgId); 43 } 44 } 45 46 // Return 200 so Scalekit does not retry this event. 47 return ResponseEntity.ok().build(); 48 } 49 } ``` ## Decrement the count when a user is removed [Section titled “Decrement the count when a user is removed”](#decrement-the-count-when-a-user-is-removed) The `user_deleted` handler decreases the seat counter and clears any pending seat-limit notification. This lets the next `user_created` event succeed without manual intervention from your team. * Node.js webhook-handler.ts ```ts 1 if (event.type === 'organization.directory.user_deleted') { 2 const orgId = event.organization_id 3 const directoryUser = event.data 4 5 await db.transaction(async (tx) => { 6 // Remove the user and decrement the counter atomically. 7 await tx.query('DELETE FROM users WHERE id = $1', [directoryUser.id]) 8 await tx.query( 9 'UPDATE org_seat_usage SET used_seats = GREATEST(used_seats - 1, 0) WHERE org_id = $1', 10 [orgId] 11 ) 12 // Clear any pending seat-limit notification so the next user can be provisioned. 13 await tx.query( 14 "DELETE FROM notifications WHERE org_id = $1 AND type = 'seat_limit_reached'", 15 [orgId] 16 ) 17 }) 18 } ``` * Python webhook\_handler.py ```python 1 if event.get('type') == 'organization.directory.user_deleted': 2 org_id = event['organization_id'] 3 directory_user = event['data'] 4 5 with db.transaction() as tx: 6 # Remove the user and decrement the counter atomically. 7 tx.execute('DELETE FROM users WHERE id = %s', (directory_user['id'],)) 8 tx.execute( 9 'UPDATE org_seat_usage SET used_seats = GREATEST(used_seats - 1, 0) ' 10 'WHERE org_id = %s', 11 (org_id,) 12 ) 13 # Clear any pending seat-limit notification so the next user can be provisioned. 14 tx.execute( 15 "DELETE FROM notifications WHERE org_id = %s AND type = 'seat_limit_reached'", 16 (org_id,) 17 ) ``` * Go webhook\_handler.go ```go 1 if event["type"] == "organization.directory.user_deleted" { 2 orgID := event["organization_id"].(string) 3 data := event["data"].(map[string]interface{}) 4 5 tx, _ := db.Begin() 6 // Remove the user and decrement the counter atomically. 7 tx.Exec("DELETE FROM users WHERE id = $1", data["id"]) 8 tx.Exec( 9 "UPDATE org_seat_usage SET used_seats = GREATEST(used_seats - 1, 0) WHERE org_id = $1", 10 orgID, 11 ) 12 // Clear any pending seat-limit notification so the next user can be provisioned. 13 tx.Exec( 14 "DELETE FROM notifications WHERE org_id = $1 AND type = 'seat_limit_reached'", 15 orgID, 16 ) 17 tx.Commit() 18 } ``` * Java WebhookController.java ```java 1 if ("organization.directory.user_deleted".equals(event.get("type"))) { 2 String orgId = (String) event.get("organization_id"); 3 Map directoryUser = (Map) event.get("data"); 4 5 transactionTemplate.execute(status -> { 6 // Remove the user and decrement the counter atomically. 7 db.update("DELETE FROM users WHERE id = ?", directoryUser.get("id")); 8 db.update( 9 "UPDATE org_seat_usage SET used_seats = GREATEST(used_seats - 1, 0) WHERE org_id = ?", 10 orgId 11 ); 12 // Clear any pending seat-limit notification so the next user can be provisioned. 13 db.update( 14 "DELETE FROM notifications WHERE org_id = ? AND type = 'seat_limit_reached'", 15 orgId 16 ); 17 return null; 18 }); 19 } ``` ## Notify admins without spamming them [Section titled “Notify admins without spamming them”](#notify-admins-without-spamming-them) A new `user_created` event fires for every blocked user. Without deduplication, your admin will receive one email per rejected provisioning attempt. Use an idempotent insert to fire the notification only once per organization until the condition is resolved. db/schema.sql ```sql 1 CREATE TABLE notifications ( 2 id SERIAL PRIMARY KEY, 3 org_id TEXT NOT NULL, 4 type TEXT NOT NULL, 5 resolved BOOLEAN NOT NULL DEFAULT FALSE, 6 created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), 7 UNIQUE (org_id, type, resolved) 8 ); ``` The `UNIQUE (org_id, type, resolved)` constraint blocks duplicate active notifications. Insert with `ON CONFLICT DO NOTHING` to skip the insert when a notification already exists: * Node.js notify.ts ```ts 1 async function notifyAdminSeatLimitReached(orgId: string) { 2 // Insert only if no unresolved notification exists for this org. 3 const result = await db.query( 4 `INSERT INTO notifications (org_id, type, resolved) 5 VALUES ($1, 'seat_limit_reached', FALSE) 6 ON CONFLICT (org_id, type, resolved) DO NOTHING`, 7 [orgId] 8 ) 9 10 // rowCount is 0 when the conflict was skipped — admin already notified. 11 if (result.rowCount === 0) return 12 13 // Send the alert once: email, Slack, in-app — your choice. 14 await sendAdminAlert(orgId, 'Seat limit reached — users are not being provisioned.') 15 } ``` * Python notify.py ```python 1 def notify_admin_seat_limit_reached(org_id: str) -> None: 2 # Insert only if no unresolved notification exists for this org. 3 result = db.execute( 4 """INSERT INTO notifications (org_id, type, resolved) 5 VALUES (%s, 'seat_limit_reached', FALSE) 6 ON CONFLICT (org_id, type, resolved) DO NOTHING""", 7 (org_id,) 8 ) 9 10 # rowcount is 0 when the conflict was skipped — admin already notified. 11 if result.rowcount == 0: 12 return 13 14 # Send the alert once: email, Slack, in-app — your choice. 15 send_admin_alert(org_id, 'Seat limit reached — users are not being provisioned.') ``` * Go notify.go ```go 1 func notifyAdminSeatLimitReached(orgID string) { 2 // Insert only if no unresolved notification exists for this org. 3 result, _ := db.Exec( 4 `INSERT INTO notifications (org_id, type, resolved) 5 VALUES ($1, 'seat_limit_reached', FALSE) 6 ON CONFLICT (org_id, type, resolved) DO NOTHING`, 7 orgID, 8 ) 9 10 // RowsAffected is 0 when the conflict was skipped — admin already notified. 11 rows, _ := result.RowsAffected() 12 if rows == 0 { 13 return 14 } 15 16 // Send the alert once: email, Slack, in-app — your choice. 17 sendAdminAlert(orgID, "Seat limit reached — users are not being provisioned.") 18 } ``` * Java NotificationService.java ```java 1 public void notifyAdminSeatLimitReached(String orgId) { 2 // Insert only if no unresolved notification exists for this org. 3 int rows = db.update( 4 "INSERT INTO notifications (org_id, type, resolved) " + 5 "VALUES (?, 'seat_limit_reached', FALSE) " + 6 "ON CONFLICT (org_id, type, resolved) DO NOTHING", 7 orgId 8 ); 9 10 // rows is 0 when the conflict was skipped — admin already notified. 11 if (rows == 0) return; 12 13 // Send the alert once: email, Slack, in-app — your choice. 14 sendAdminAlert(orgId, "Seat limit reached — users are not being provisioned."); 15 } ``` When a user is removed and the count drops below the limit, the `user_deleted` handler deletes the notification row. The next blocked `user_created` event will insert a fresh notification and trigger a new alert. *** **Related guides** * [SCIM provisioning quickstart](/directory/scim/quickstart/) — set up webhooks and the Directory API, including signature verification * [Directory webhook events reference](/directory/reference/directory-events/) — full event payload schemas --- # DOCUMENT BOUNDARY --- # Search Scalekit docs with ref.tools > Configure ref.tools MCP to search Scalekit documentation directly from Cursor, Claude Code, or Windsurf without leaving your IDE. Every time you need to look up a Scalekit API, scope name, or configuration option, you break your flow: open a new tab, search the docs, copy the answer, switch back. With ref.tools configured as an MCP server, your AI coding assistant can search Scalekit documentation inline and return accurate, up-to-date answers without you leaving the editor. Setup takes about two minutes. ## The problem [Section titled “The problem”](#the-problem) AI coding assistants are good at generating code, but they have two failure modes when it comes to third-party docs: * **Hallucination** — The model invents an API that doesn’t exist or gets parameter names wrong because its training data is incomplete * **Stale knowledge** — Even accurate training data goes out of date as SDKs and APIs evolve Both problems get worse when you’re working with a narrowly scoped platform like Scalekit. The model may have seen very little training data about it, and what it did see may be outdated. The standard workaround is to paste docs into the chat manually — which means constant context-switching between your editor and a browser. ref.tools solves both problems by connecting your AI assistant directly to live Scalekit documentation through an MCP tool call. ## Who needs this [Section titled “Who needs this”](#who-needs-this) This cookbook is for you if: * ✅ You use Cursor, Claude Code, Windsurf, or another MCP-compatible AI assistant * ✅ You’re building with Scalekit (auth, SSO, MCP servers, M2M, SCIM) * ✅ You want accurate, up-to-date answers without context-switching to a browser You **don’t** need this if: * ❌ You prefer pasting docs into your chat manually * ❌ Your AI assistant doesn’t support MCP ## The solution [Section titled “The solution”](#the-solution) [ref.tools](https://ref.tools) is a documentation search platform that indexes third-party docs — including Scalekit — and exposes them as an MCP tool called `ref_search_documentation`. Once you add the ref.tools MCP server to your AI assistant, you can prompt it to search Scalekit docs and it will call the tool and return current results directly in chat. The server supports two transports: * **Streamable HTTP** (recommended) — Direct HTTP connection using your API key; lower latency, no local process required * **stdio** (legacy) — Runs a local `npx` process; works with any MCP client that supports stdio ## Set up ref.tools [Section titled “Set up ref.tools”](#set-up-reftools) 1. ### Get your API key [Section titled “Get your API key”](#get-your-api-key) 1. Go to [ref.tools](https://ref.tools) and sign in 2. Search for **Scalekit** to confirm the documentation source is indexed 3. Open the **Quick Install** panel for Scalekit — your API key is pre-filled in the install commands 4. Copy your API key; you’ll use it in the next step 2. ### Add the MCP server to your AI assistant [Section titled “Add the MCP server to your AI assistant”](#add-the-mcp-server-to-your-ai-assistant) Pick your tool and apply the matching configuration. #### Claude Code [Section titled “Claude Code”](#claude-code) Run this command in your terminal to add the MCP server globally across all projects: ```bash 1 claude mcp add --transport http ref-context https://api.ref.tools/mcp \ 2 --header "x-ref-api-key: YOUR_API_KEY" ``` To scope it to a single project instead, add `--scope project` to the command. #### Cursor [Section titled “Cursor”](#cursor) Add the following to `.cursor/mcp.json` in your project root (or via **Settings → MCP**): .cursor/mcp.json ```json 1 { 2 "ref-context": { 3 "type": "http", 4 "url": "https://api.ref.tools/mcp?apiKey=YOUR_API_KEY" 5 } 6 } ``` #### Windsurf [Section titled “Windsurf”](#windsurf) Add the following to `~/.codeium/windsurf/mcp_config.json`: \~/.codeium/windsurf/mcp\_config.json ```json 1 { 2 "ref-context": { 3 "serverUrl": "https://api.ref.tools/mcp?apiKey=YOUR_API_KEY" 4 } 5 } ``` #### Other (stdio) [Section titled “Other (stdio)”](#other-stdio) For any MCP client that supports stdio, add to your MCP config: mcp.json ```json 1 { 2 "ref-context": { 3 "command": "npx", 4 "args": ["ref-tools-mcp@latest"], 5 "env": { 6 "REF_API_KEY": "YOUR_API_KEY" 7 } 8 } 9 } ``` This requires Node.js installed locally. The `npx` command fetches and runs the server on first use. 3. ### Verify it’s working [Section titled “Verify it’s working”](#verify-its-working) 1. Restart your AI assistant (or use its MCP reload command if available) 2. Open a new chat and send this prompt: ```plaintext 1 Use ref to look up how to add OAuth 2.1 authorization to an MCP server with Scalekit ``` 3. Your assistant should call the `ref_search_documentation` tool and return results from `docs.scalekit.com` If the tool doesn’t appear, check that you restarted the assistant after saving the config, and that the API key is correct. Keep your API key private Never commit your ref.tools API key to source control. For project-level configs checked into git, pass the key through an environment variable and reference it as `$REF_API_KEY` in your config, or add the config file to `.gitignore`. ## Example searches to try [Section titled “Example searches to try”](#example-searches-to-try) Once ref.tools is connected, use phrases like “use ref to…” or “look up in ref…” to trigger the tool explicitly: * `Use ref to find the Scalekit MCP auth quickstart` * `Look up how to configure SSO with Scalekit` * `Use ref to find Scalekit M2M token documentation` * `Search Scalekit docs for SCIM provisioning setup` * `Use ref to look up Scalekit SDK environment variables` You can also just ask naturally — most assistants will call the tool automatically when the question is about Scalekit. ## Common mistakes [Section titled “Common mistakes”](#common-mistakes) ## Next steps [Section titled “Next steps”](#next-steps) For further setup, authentication options, and available documentation sources, see the links below. * [Add OAuth 2.1 authorization to MCP servers](/authenticate/mcp/quickstart) — the most common thing developers look up using ref * [ref.tools](https://ref.tools) — browse all available documentation sources you can add alongside Scalekit * [M2M authentication overview](/guides/m2m/overview) — machine-to-machine auth patterns frequently searched via ref --- # DOCUMENT BOUNDARY --- # Set up AgentKit with your coding agent > Add Scalekit Agent Auth to your codebase using Claude Code, Codex, GitHub Copilot CLI, Cursor, or any of 40+ coding agents. Install the authstack plugin into your coding agent and paste one prompt. The agent generates client initialization, connected account management, OAuth authorization, and token handling — no boilerplate required. ## Before you start [Section titled “Before you start”](#before-you-start) * A Scalekit account at [app.scalekit.com](https://app.scalekit.com) * A connector configured under **AgentKit** > **Connections** (for example, `github-connect`, the default GitHub connection in new environments) * Your API credentials from **Developers → API Credentials** ## Pick your coding agent [Section titled “Pick your coding agent”](#pick-your-coding-agent) * Recommended: one command Terminal ```bash npx @scalekit-inc/cli setup ``` For repeated use: `npm install -g @scalekit-inc/cli` then `scalekit setup`. The CLI installs the authstack plugin (including Agent Auth skills) for your editor. Complete any browser OAuth prompt for the Scalekit MCP server. Then paste the implementation prompt (or describe your goal naturally). * Per-tool details After the CLI (or if you prefer tool-native flows): * Claude Code / Copilot: marketplace + plugin install is handled by the CLI. * Cursor / Codex: plugins are installed locally by the CLI. * 40+ agents: use the skills option in the CLI or `npx skills add scalekit-inc/authstack --skill integrating-agentkit`. Use the prompt below. ## Verify the setup [Section titled “Verify the setup”](#verify-the-setup) 1. **Set environment variables** — copy `SCALEKIT_CLIENT_ID`, `SCALEKIT_CLIENT_SECRET`, and `SCALEKIT_ENV_URL` from the dashboard → **API Credentials**. 2. **Trigger the authorization flow** — run the generated example and confirm the browser redirects to the connector’s consent page. 3. **Fetch a token** — after consent, call the token-fetch function and confirm you receive a valid response. Review generated code before deploying Verify that token validation logic, error handling, and environment variable references match your application’s requirements. The generated code is a foundation, not a finished implementation. ## Troubleshooting [Section titled “Troubleshooting”](#troubleshooting) --- # DOCUMENT BOUNDARY --- # Sync B2B billing with Scalekit and Chargebee > Map Scalekit organizations to Chargebee customers, run hosted checkout, and keep subscription state in sync via webhooks. Multi-tenant B2B SaaS apps authenticate users through Scalekit organizations, but bill through Chargebee subscriptions. Those two systems do not share a database. Without an explicit mapping, you end up with duplicate Chargebee customers, subscriptions that never activate after checkout, or feature gates that read stale plan data. This cookbook wires Scalekit organizations and sessions to Chargebee using **org-mode billing**: the organization ID from the access token (`oid`) becomes the billing `referenceId`, Scalekit webhooks provision Chargebee customers, and Chargebee webhooks keep your local subscription table current. You own the routes, schema, and authorization that connect the two systems. ## What you get [Section titled “What you get”](#what-you-get) * Chargebee customers created when Scalekit fires `organization.created` (not on every user signup) * Local org ↔ Chargebee customer mapping keyed by the Scalekit organization ID * Hosted checkout and customer portal via Chargebee hosted pages * Local subscription cache driven by Chargebee webhooks, plus optional eager sync on checkout redirect * Session-scoped authorization so billing APIs only act on the caller’s org (`referenceId === oid`) * Lifecycle hooks for product logic (after customer create, subscription complete/cancel, authorize deny) ## Who needs this [Section titled “Who needs this”](#who-needs-this) This cookbook is for you if: * ✅ You authenticate with Scalekit and use **organizations** (`oid` in access tokens) * ✅ You bill **per organization**, not per individual user * ✅ You use Chargebee hosted checkout or the customer portal * ✅ You maintain a local subscription cache to gate features in your app You **don’t** need this if: * ❌ You bill per user, not per organization * ❌ Scalekit manages your entire product catalog and entitlements (no separate billing system) ## How the integration fits together [Section titled “How the integration fits together”](#how-the-integration-fits-together) Treat the Scalekit **organization ID** as the single billing reference for the tenant. Scalekit authenticates the user and org, your app owns the mapping and local subscription cache, and Chargebee owns catalog, checkout, and billing state. ![Architecture: User logs in via Scalekit, app provisions Chargebee customers and hosted checkout, Chargebee returns checkout success and subscription webhooks, app stores org mapping and subscription cache in local DB](/.netlify/images?url=_astro%2Farchitecture.Cp7V-ALL.png\&w=1568\&h=740\&dpl=6a7afd35ca95e20008d421ee) The integration has four seams: 1. **Provision on org create** — Scalekit `organization.created` webhook → create a Chargebee customer and store the mapping locally. 2. **Authorize every billing call** — session `oid` must match the billing `referenceId` before any Chargebee API call. 3. **Future subscription before checkout** — create a local row with `status: future`, stamp `pendingSubscriptionId` on Chargebee customer metadata, then redirect to hosted checkout. 4. **Reconcile from Chargebee** — subscription webhooks (and an eager sync on checkout redirect) update the local row to `active`, `in_trial`, or cancelled. Screenshots below are from the [reference demo](https://github.com/scalekit-developers/saas-auth-chargebee-example) so you can match each milestone to the product UI. ## Before you start [Section titled “Before you start”](#before-you-start) | Prerequisite | Where to get it | | ---------------------------------------------------------- | -------------------------------------------------------------- | | Scalekit environment with organizations | [Scalekit dashboard](https://app.scalekit.com/) | | OAuth client (`skc_...`) + redirect URI | **API Keys** in the dashboard | | Chargebee sandbox site (Product Catalog 2.0) | Chargebee test site | | Plan **item price** ID (for example `growth-plan-monthly`) | Chargebee **Product Catalog** — reference prices by ID in code | | Test payment gateway (`gw_...`) | Chargebee **Payment Gateways** | | Public tunnel for webhooks | ngrok, LocalTunnel, or similar | ## Step 1: Install packages [Section titled “Step 1: Install packages”](#step-1-install-packages) Install the Scalekit and Chargebee SDKs on the **server** (API routes, webhook handlers). Use whichever package manager you use in your app (`npm`, `pnpm`, or `yarn`); the example below matches the reference app: Terminal ```bash 1 npm install @scalekit-sdk/node chargebee ``` Snippets in this cookbook are **Node.js / Next.js App Router**, aligned with the reference app. Scalekit client concepts (token validation, webhook verification, `oid`) apply across SDKs; adapt routes and session storage if you run another stack. Chargebee’s primary SDK surface used here is the Node package. Use your ORM of choice for the local billing tables (the reference app uses Drizzle + SQLite). Keep Chargebee secret API keys server-side only; publishable keys for Chargebee.js may use `NEXT_PUBLIC_*` if you embed payment components. ## Step 2: Configure environment variables [Section titled “Step 2: Configure environment variables”](#step-2-configure-environment-variables) Define these in your server environment (for example `.env` locally and your host’s secrets store in production). | Variable | Purpose | | ----------------------------------------------------------- | ------------------------------------------------------------------ | | `SCALEKIT_ENV_URL` | Scalekit environment URL | | `SCALEKIT_CLIENT_ID` / `SCALEKIT_CLIENT_SECRET` | OAuth client | | `SCALEKIT_REDIRECT_URI` | OAuth callback (for example `http://localhost:3000/auth/callback`) | | `SCALEKIT_WEBHOOK_SECRET` | Verify Scalekit webhook signatures | | `CHARGEBEE_SITE` | Chargebee site subdomain | | `CHARGEBEE_API_KEY` | Full-access API key for your Chargebee site | | `CHARGEBEE_PLAN_ITEM_PRICE_ID` | Default plan item price ID from Product Catalog 2.0 | | `CHARGEBEE_GATEWAY_ACCOUNT_ID` | Optional gateway pin for hosted checkout (`gw_...`) | | `CHARGEBEE_WEBHOOK_USERNAME` / `CHARGEBEE_WEBHOOK_PASSWORD` | Basic Auth for Chargebee webhooks (recommended in production) | | `NEXT_PUBLIC_APP_URL` | App base URL for hosted-page redirects | .env.example ```bash 1 SCALEKIT_ENV_URL=https://your-env.scalekit.dev 2 SCALEKIT_CLIENT_ID=skc_... 3 SCALEKIT_CLIENT_SECRET= 4 SCALEKIT_REDIRECT_URI=http://localhost:3000/auth/callback 5 SCALEKIT_WEBHOOK_SECRET= 6 CHARGEBEE_SITE=your-site-test 7 CHARGEBEE_API_KEY= 8 CHARGEBEE_PLAN_ITEM_PRICE_ID=growth-plan-monthly 9 CHARGEBEE_GATEWAY_ACCOUNT_ID=gw_your_test_gateway_id 10 CHARGEBEE_WEBHOOK_USERNAME= 11 CHARGEBEE_WEBHOOK_PASSWORD= 12 NEXT_PUBLIC_APP_URL=http://localhost:3000 ``` ## Step 3: Add local schema [Section titled “Step 3: Add local schema”](#step-3-add-local-schema) Add tables for organizations, subscriptions, and optional line items. The organization row holds the Chargebee customer ID; subscriptions are keyed by `reference_id` (the Scalekit org ID from `oid`). Default new subscriptions to `future` so checkout can reconcile before Chargebee assigns a subscription ID. db/schema.sql ```sql 1 CREATE TABLE organization ( 2 id TEXT PRIMARY KEY, 3 display_name TEXT, 4 chargebee_customer_id TEXT UNIQUE, 5 updated_at INTEGER 6 ); 7 8 CREATE TABLE subscription ( 9 id TEXT PRIMARY KEY, 10 reference_id TEXT NOT NULL, 11 chargebee_customer_id TEXT, 12 chargebee_subscription_id TEXT UNIQUE, 13 status TEXT NOT NULL DEFAULT 'future', 14 period_start INTEGER, 15 period_end INTEGER, 16 trial_start INTEGER, 17 trial_end INTEGER, 18 canceled_at INTEGER, 19 seats INTEGER, 20 metadata TEXT 21 ); 22 23 CREATE TABLE subscription_item ( 24 id TEXT PRIMARY KEY, 25 subscription_id TEXT NOT NULL REFERENCES subscription(id) ON DELETE CASCADE, 26 item_price_id TEXT NOT NULL, 27 item_type TEXT NOT NULL, 28 quantity INTEGER NOT NULL, 29 unit_price INTEGER, 30 amount INTEGER 31 ); ``` Translate to your ORM. Index `reference_id` — webhook handlers and list endpoints query by org ID on every request. **After this step:** migrations applied; empty tables ready for provisioning and checkout. ## Step 4: Initialize clients [Section titled “Step 4: Initialize clients”](#step-4-initialize-clients) Create lazy singletons from environment variables. Never hardcode API keys. lib/scalekit.ts ```ts 1 import { ScalekitClient } from '@scalekit-sdk/node'; 2 3 let scalekitClient: ScalekitClient | null = null; 4 5 export function getScalekitClient(): ScalekitClient { 6 if (!scalekitClient) { 7 const envUrl = process.env.SCALEKIT_ENV_URL; 8 const clientId = process.env.SCALEKIT_CLIENT_ID; 9 const clientSecret = process.env.SCALEKIT_CLIENT_SECRET; 10 if (!envUrl || !clientId || !clientSecret) { 11 throw new Error( 12 'Set SCALEKIT_ENV_URL, SCALEKIT_CLIENT_ID, and SCALEKIT_CLIENT_SECRET.' 13 ); 14 } 15 scalekitClient = new ScalekitClient(envUrl, clientId, clientSecret); 16 } 17 return scalekitClient; 18 } ``` lib/chargebee.ts ```ts 1 import Chargebee from 'chargebee'; 2 3 let chargebeeClient: Chargebee | null = null; 4 5 export function getChargebeeClient(): Chargebee { 6 if (!chargebeeClient) { 7 const site = process.env.CHARGEBEE_SITE; 8 const apiKey = process.env.CHARGEBEE_API_KEY; 9 if (!site || !apiKey) { 10 throw new Error('Set CHARGEBEE_SITE and CHARGEBEE_API_KEY.'); 11 } 12 chargebeeClient = new Chargebee({ site, apiKey }); 13 } 14 return chargebeeClient; 15 } ``` ## Step 5: Provision Chargebee customers from Scalekit webhooks [Section titled “Step 5: Provision Chargebee customers from Scalekit webhooks”](#step-5-provision-chargebee-customers-from-scalekit-webhooks) Register a Scalekit webhook for `organization.created`, `organization.updated`, and `organization.deleted`. Point it at your public URL (use a tunnel in local dev): ```text 1 https://your-domain.com/api/webhooks/scalekit ``` Verify the signature on the **raw request body** before parsing JSON. Verify webhook signatures Never parse the body before verification. Re-serialized JSON breaks signature checks. Read `req.text()` (or the raw buffer), verify, then `JSON.parse`. api/webhooks/scalekit/route.ts ```ts 1 import { NextRequest, NextResponse } from 'next/server'; 2 import { getScalekitClient } from '@/lib/scalekit'; 3 import { createOrgCustomer } from '@/lib/billing/create-org-customer'; 4 import { cleanupOrganizationBilling } from '@/lib/billing/cleanup-org'; 5 import { upsertOrganization } from '@/lib/db/organizations'; 6 7 export async function POST(req: NextRequest) { 8 const rawBody = await req.text(); 9 const secret = process.env.SCALEKIT_WEBHOOK_SECRET; 10 if (!secret) { 11 return NextResponse.json({ error: 'Webhook secret not configured' }, { status: 500 }); 12 } 13 14 const headers: Record = {}; 15 req.headers.forEach((value, key) => { 16 headers[key.toLowerCase()] = value; 17 }); 18 19 const client = getScalekitClient(); 20 const isValid = client.verifyWebhookPayload(secret, headers, rawBody); 21 if (!isValid) { 22 return NextResponse.json({ error: 'Invalid signature' }, { status: 401 }); 23 } 24 25 const event = JSON.parse(rawBody); 26 const organizationId = event.organization_id ?? event.data?.id; 27 28 if (event.type === 'organization.created' && organizationId) { 29 await createOrgCustomer({ 30 organizationId, 31 displayName: event.data?.display_name ?? null, 32 }); 33 } else if (event.type === 'organization.updated' && organizationId) { 34 await upsertOrganization({ 35 id: organizationId, 36 displayName: event.data?.display_name ?? null, 37 }); 38 } else if (event.type === 'organization.deleted' && organizationId) { 39 await cleanupOrganizationBilling(organizationId); 40 } 41 42 return NextResponse.json({ received: true }); 43 } ``` `createOrgCustomer` upserts the local organization row, creates a Chargebee customer if one does not exist, and stores `organizationId` in Chargebee `meta_data`. Make it idempotent: check the local mapping before calling `customer.create`, and handle races if checkout runs before the webhook finishes. lib/billing/create-org-customer.ts ```ts 1 const { customer } = await chargebee.customer.create({ 2 company: displayName ?? undefined, 3 email: email ?? undefined, 4 preferred_currency_code: 'USD', 5 meta_data: { 6 organizationId, 7 customerType: 'organization', 8 }, 9 }); 10 11 await setChargebeeCustomerId(organizationId, customer.id); ``` Return `2xx` after accepting the event. Scalekit retries on non-2xx responses. The reference app enqueues work with `setImmediate` so the HTTP response is fast; either pattern works if handlers are idempotent. **After this step:** create an organization in Scalekit → local `organization` row and a Chargebee customer with matching `organizationId` metadata appear. In the reference app dashboard, steps 1–3 show **Done** and the org is linked to a Chargebee customer before you open billing: ![Dashboard after sign-in: organization linked to Chargebee customer, subscribe step current](/.netlify/images?url=_astro%2F02-dashboard-org-linked.5twfG6-G.png\&w=3024\&h=1780\&dpl=6a7afd35ca95e20008d421ee) ## Step 6: Read the organization ID from the session [Section titled “Step 6: Read the organization ID from the session”](#step-6-read-the-organization-id-from-the-session) Billing routes need org context from the access token. Validate the token on every request and require the `oid` claim. Do not call `/userinfo` for billing context. lib/auth/require-session.ts ```ts 1 import { decodeJwt } from 'jose'; 2 3 const isValid = await scalekit.validateAccessToken(accessToken); 4 if (!isValid) { 5 throw new SessionError(401, 'Invalid or expired token'); 6 } 7 8 // Safe after validateAccessToken: signature and standard claims already checked. 9 const claims = decodeJwt(accessToken); 10 11 const organizationId = claims.oid as string | undefined; 12 if (!organizationId) { 13 throw new SessionError(403, 'Organization context required for billing'); 14 } 15 16 return { 17 userId: claims.sub as string, 18 email: claims.email as string, 19 organizationId, 20 }; ``` ## Step 7: Authorize billing references [Section titled “Step 7: Authorize billing references”](#step-7-authorize-billing-references) Before any Chargebee API call, confirm the caller’s session org matches the billing reference. Extend with a product hook to deny delinquent orgs without changing Chargebee configuration. lib/auth/authorize-reference.ts ```ts 1 export type AuthorizeReferenceAction = 2 | 'create' 3 | 'update' 4 | 'cancel' 5 | 'portal' 6 | 'list'; 7 8 export async function authorizeReference({ 9 userId, 10 organizationId, 11 referenceId, 12 action, 13 }: { 14 userId: string; 15 organizationId: string; 16 referenceId: string; 17 action: AuthorizeReferenceAction; 18 }): Promise { 19 if (referenceId !== organizationId) { 20 return false; 21 } 22 // Optional: return false from onAuthorizeReference to deny specific orgs. 23 return onAuthorizeReference({ userId, organizationId, referenceId, action }) !== false; 24 } ``` **After this step:** a request with `referenceId` that does not match session `oid` returns `403` before Chargebee is called. ## Step 8: Start hosted checkout with a future subscription [Section titled “Step 8: Start hosted checkout with a future subscription”](#step-8-start-hosted-checkout-with-a-future-subscription) When an org admin clicks **Subscribe**, create a local `future` row first, stamp pending IDs on the Chargebee customer, then call `hostedPage.checkoutNewForItems`. Use **item price IDs** from your Chargebee product catalog. api/subscription/create/route.ts ```ts 1 const ctx = await requireSession(); 2 const referenceId = body.referenceId ?? ctx.organizationId; 3 4 if ( 5 !(await authorizeReference({ 6 userId: ctx.userId, 7 organizationId: ctx.organizationId, 8 referenceId, 9 action: 'create', 10 })) 11 ) { 12 return NextResponse.json({ error: 'Forbidden' }, { status: 403 }); 13 } 14 15 const active = await findActiveByReferenceId(referenceId); 16 if (active) { 17 return NextResponse.json( 18 { error: 'An active subscription already exists for this organization' }, 19 { status: 400 } 20 ); 21 } 22 23 const customerId = await getOrCreateCustomerId({ 24 organizationId: referenceId, 25 email: ctx.email, 26 }); 27 28 const localSub = await createFutureSubscription({ 29 referenceId, 30 chargebeeCustomerId: customerId, 31 }); 32 33 await chargebee.customer.update(customerId, { 34 meta_data: { 35 pendingSubscriptionId: localSub.id, 36 pendingReferenceId: referenceId, 37 organizationId: referenceId, 38 userId: ctx.userId, 39 }, 40 }); 41 42 const result = await chargebee.hostedPage.checkoutNewForItems({ 43 subscription_items: [{ item_price_id: planItemPriceId, quantity: seats }], 44 customer: { id: customerId }, 45 redirect_url: successRedirect, // includes local subscriptionId for eager sync 46 cancel_url: absoluteUrl(cancelUrl), 47 // Optional: pin gateway when Smart Routing cannot auto-select 48 // ...getHostedCheckoutCardOptions(), 49 }); 50 51 return NextResponse.json({ mode: 'hosted', url: result.hosted_page.url }); ``` The `future` row gives your app a stable ID to reconcile against before Chargebee assigns a subscription ID. Reject create when an active subscription already exists for the org. **After this step:** `POST /api/subscription/create` returns `{ mode: 'hosted', url }`; completing checkout in the sandbox creates or updates the Chargebee subscription. In the demo, the billing page lists plans scoped to the session org. **Subscribe** calls your create route, then redirects to Chargebee hosted pages: ![Billing page: Growth plan with Subscribe, integration journey on subscribe step](/.netlify/images?url=_astro%2F03-billing-choose-plan.B2QfAshm.png\&w=3024\&h=1780\&dpl=6a7afd35ca95e20008d421ee) ![Chargebee hosted cart: Growth Plan monthly with 14-day free trial](/.netlify/images?url=_astro%2F04-chargebee-cart.7xKdgMWn.png\&w=3024\&h=1780\&dpl=6a7afd35ca95e20008d421ee) ![Chargebee hosted checkout: account details, payment method, and order summary](/.netlify/images?url=_astro%2F05-chargebee-checkout.D0JjaVN1.png\&w=3024\&h=1780\&dpl=6a7afd35ca95e20008d421ee) ## Step 9: Configure Chargebee webhooks [Section titled “Step 9: Configure Chargebee webhooks”](#step-9-configure-chargebee-webhooks) In the Chargebee dashboard, create a webhook endpoint that points to: ```text 1 https://your-domain.com/api/webhooks/chargebee ``` Protect the route with HTTP Basic Auth using `CHARGEBEE_WEBHOOK_USERNAME` and `CHARGEBEE_WEBHOOK_PASSWORD`. Enter the same credentials under Basic Authentication in the Chargebee webhook settings. Subscribe at least to these events (names as in Chargebee / the Node SDK): | Chargebee event | Action | | ------------------------------------------------- | --------------------------------------------------- | | `subscription_created` | Link `chargebee_subscription_id`, set status | | `subscription_activated` / `subscription_started` | Mark `active` or `in_trial`, run entitlements hooks | | `subscription_changed` / `subscription_renewed` | Update plan, seats, period dates | | `subscription_cancelled` | Mark cancelled, revoke entitlements | | `customer_deleted` | Clear local customer mapping | Lookup order when matching a webhook to a local row: 1. `chargebee_subscription_id` on the local row 2. Subscription metadata (if you stamp IDs on the Chargebee subscription) 3. `meta_data.pendingSubscriptionId` on the Chargebee customer 4. `future` row by `reference_id` api/webhooks/chargebee/route.ts ```ts 1 import { NextRequest, NextResponse } from 'next/server'; 2 import { 3 WebhookAuthenticationError, 4 basicAuthValidator, 5 } from 'chargebee'; 6 import { processChargebeeWebhookEvent } from '@/lib/billing/chargebee-webhook-handler'; 7 8 export async function POST(req: NextRequest) { 9 const username = process.env.CHARGEBEE_WEBHOOK_USERNAME; 10 const password = process.env.CHARGEBEE_WEBHOOK_PASSWORD; 11 12 const headers: Record = {}; 13 req.headers.forEach((value, key) => { 14 headers[key.toLowerCase()] = value; 15 }); 16 17 if (username && password) { 18 try { 19 await basicAuthValidator( 20 (user, pass) => user === username && pass === password 21 )(headers); 22 } catch (err) { 23 if (err instanceof WebhookAuthenticationError) { 24 return NextResponse.json({ error: 'Unauthorized' }, { status: 401 }); 25 } 26 return NextResponse.json({ error: 'Unauthorized' }, { status: 401 }); 27 } 28 } 29 30 const event = await req.json(); 31 await processChargebeeWebhookEvent(event); 32 return NextResponse.json({ received: true }); 33 } ``` **After this step:** cancel or change a plan in Chargebee → local subscription status updates without a page refresh loop. After a successful checkout (and webhook or eager sync), the billing UI shows the live plan status — for example **In Trial** — and the journey marks subscribe and webhook sync as **Done**: ![Billing after checkout: In Trial subscription and integration journey complete through webhook sync](/.netlify/images?url=_astro%2F06-billing-subscription-active.bChq_VBK.png\&w=3024\&h=1780\&dpl=6a7afd35ca95e20008d421ee) ## Step 10: Eager-sync on checkout redirect [Section titled “Step 10: Eager-sync on checkout redirect”](#step-10-eager-sync-on-checkout-redirect) Hosted checkout redirects to your success URL before webhooks arrive. Add an eager sync so the billing page shows the subscription immediately. Webhooks remain the source of truth for ongoing changes. api/subscription/success/route.ts ```ts 1 export async function GET(request: NextRequest) { 2 const subscriptionId = request.nextUrl.searchParams.get('subscriptionId'); 3 const callbackURL = 4 request.nextUrl.searchParams.get('callbackURL') ?? '/billing?success=1'; 5 6 if (subscriptionId) { 7 const local = await findSubscriptionById(subscriptionId); 8 if (local?.chargebeeSubscriptionId) { 9 const result = await chargebee.subscription.retrieve( 10 local.chargebeeSubscriptionId 11 ); 12 await syncLocalFromChargebeeSubscription(local, result.subscription); 13 } else if (local?.chargebeeCustomerId) { 14 // Fallback: list recent subscriptions for the customer and sync the latest 15 const result = await chargebee.subscription.subscriptionsForCustomer( 16 local.chargebeeCustomerId, 17 { limit: 10 } 18 ); 19 // ...sync latest to local row 20 } 21 } 22 23 return NextResponse.redirect(new URL(callbackURL, request.url)); 24 } ``` Validate `callbackURL` against an allowlist of relative paths so redirects cannot leave your site. ## Define plans [Section titled “Define plans”](#define-plans) Customer provisioning works without a plan catalog in code. To sell plans, map Chargebee **item price IDs** to names, limits, and optional trials. Keep pricing ownership in Chargebee; store entitlement metadata in your app. **Static configuration** (fine for a small catalog): lib/billing/plans.ts ```ts 1 export type PlanConfig = { 2 itemPriceId: string; 3 name: string; 4 limits: Record; 5 freeTrial?: { days: number }; 6 }; 7 8 export const PLANS: PlanConfig[] = [ 9 { 10 itemPriceId: 11 process.env.CHARGEBEE_PLAN_ITEM_PRICE_ID ?? 'growth-plan-monthly', 12 name: 'Growth', 13 limits: { seats: 25 }, 14 freeTrial: { days: 14 }, 15 }, 16 ]; ``` **Dynamic configuration (recommended for maintainability):** load plans from your database so marketing and price IDs stay out of source control. Map rows to the same `PlanConfig` shape and fail closed if the query errors. ## Common flows [Section titled “Common flows”](#common-flows) Expand a question when you need that path. Each answer assumes the numbered steps above are in place (schema, webhooks, authorize, hosted checkout). ## Customer customization (optional) [Section titled “Customer customization (optional)”](#customer-customization-optional) Use hooks so product logic stays out of webhook routes. lib/subscription-hooks.ts ```ts 1 export async function onCustomerCreate(params: { 2 organizationId: string; 3 chargebeeCustomerId: string; 4 displayName?: string | null; 5 }): Promise { 6 // Analytics, CRM sync, internal tenant linking 7 } 8 9 export async function onSubscriptionComplete(ctx: { 10 referenceId: string; 11 subscriptionId: string; 12 chargebeeSubscriptionId: string; 13 status: string; 14 }): Promise { 15 // Enable SSO, flip feature flags, send onboarding email 16 } 17 18 /** Return false to deny billing actions for a reference. */ 19 export async function onAuthorizeReference(_params: { 20 userId: string; 21 organizationId: string; 22 referenceId: string; 23 action: 'create' | 'update' | 'cancel' | 'portal' | 'list'; 24 }): Promise { 25 return true; 26 } ``` ## Database schema overview [Section titled “Database schema overview”](#database-schema-overview) | Model | Role | | ----------------------- | ---------------------------------------------------------------------------------------------------------- | | **`organization`** | Optional `chargebee_customer_id`; primary key is the Scalekit org ID | | **`subscription`** | `reference_id` (org), Chargebee subscription/customer IDs, status, trial and period dates, seats, metadata | | **`subscription_item`** | Line items (plans, addons, charges) with quantity and pricing details | **Source of truth:** Chargebee owns catalog, invoices, and payment state. Your database is a cache for authorization and UI. After schema changes, migrate your app database the same way you migrate other tables—there is no separate billing CLI. ## Testing [Section titled “Testing”](#testing) Run this validation after wiring both webhook endpoints through a tunnel: 1. **Create an organization** in Scalekit (or fire `organization.created` from the dashboard). 2. **Confirm provisioning** — local `organization` row exists; Chargebee shows a customer with matching `organizationId` metadata. 3. **Sign in** as a user in that org and open your billing page. 4. **Start checkout** — `POST /api/subscription/create` returns `{ mode: 'hosted', url }`. Complete payment with test card `4111 1111 1111 1111`. 5. **Confirm redirect** — browser lands on `/billing?success=1` and the subscription appears without a manual refresh. 6. **Replay a webhook** — send a test `subscription_activated` event from Chargebee and confirm the local row updates. Check session org context ```bash 1 curl -s http://localhost:3000/api/session \ 2 -H "Cookie: scalekit_session=" | jq '.organizationId' ``` ## Troubleshooting [Section titled “Troubleshooting”](#troubleshooting) | Symptom | What to check | | ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------ | | Orphan org / no Chargebee customer | Scalekit webhook URL and events; `SCALEKIT_WEBHOOK_SECRET`; signature uses **raw** body; handler logs | | Webhooks ignored (Chargebee) | URL path; Basic Auth credentials match env; selected events; tunnel health | | Checkout OK, UI still free tier | Was a `future` row created? Is `pendingSubscriptionId` on the customer? Eager sync route? Chargebee webhooks delivering? | | Status out of date | `chargebee_customer_id` / `chargebee_subscription_id` populated? Event types subscribed? Handler returns 500 on DB failure so Chargebee retries? | | Billing API returns 403 | `referenceId` must equal session `oid`; do not key customers by email alone | | `no_applicable_gateway` on hosted checkout | Add a test gateway; set `CHARGEBEE_GATEWAY_ACCOUNT_ID`; enable Smart Routing | | Checkout succeeds but no redirect | `NEXT_PUBLIC_APP_URL` must be in Chargebee **Allowed redirect domains**; declined cards prevent redirect | | Duplicate Chargebee customers | Race between org webhook and first checkout — make `createOrgCustomer` idempotent | ## Production notes [Section titled “Production notes”](#production-notes) * **Replace SQLite** with Postgres or your production database. Keep the `reference_id` index. * **Rotate webhook secrets** independently for Scalekit and Chargebee. Store them in a secrets manager. * **Make handlers idempotent** — Chargebee retries; upsert by `chargebee_subscription_id`. * **Handle org deletion** — on `organization.deleted`, cancel active Chargebee subscriptions and delete local rows so billing does not continue. * **Do not expose Chargebee secret API keys client-side** — only publishable keys belong in `NEXT_PUBLIC_*` variables. ## Helpful prompts [Section titled “Helpful prompts”](#helpful-prompts) Use these FAQ-style prompts with an AI coding agent (Cursor, Claude Code, Copilot CLI, Codex, and similar). First install the Scalekit authstack plugin for your agent, then paste a prompt from a section below (replace bracketed placeholders with your stack). ### 1. Set up your coding agent [Section titled “1. Set up your coding agent”](#1-set-up-your-coding-agent) Run the Scalekit CLI setup so your agent loads Scalekit auth patterns (reduces hallucinations on sessions, webhooks, and orgs): Terminal ```bash 1 npx @scalekit-inc/cli setup ``` For repeated use: Terminal ```bash 1 npm install -g @scalekit-inc/cli 2 scalekit setup ``` `setup` with no arguments launches an interactive wizard and detects installed tools. Target one agent explicitly if you prefer: Terminal ```bash 1 npx @scalekit-inc/cli setup cursor 2 npx @scalekit-inc/cli setup claude 3 npx @scalekit-inc/cli setup codex 4 npx @scalekit-inc/cli setup copilot ``` See the [Scalekit CLI](/dev-kit/cli/) for flags and what gets installed. After setup, open your agent and use a prompt below. ### 2. Prompts (after setup) [Section titled “2. Prompts (after setup)”](#2-prompts-after-setup) ## Resources [Section titled “Resources”](#resources) * [saas-auth-chargebee-example](https://github.com/scalekit-developers/saas-auth-chargebee-example) — runnable reference app * [External IDs and metadata](/guides/external-ids-and-metadata/) — map Scalekit orgs to internal tenant IDs * [Implement webhooks](https://docs.scalekit.com/authenticate/implement-workflows/implement-webhooks/#_top) — webhook reference --- # DOCUMENT BOUNDARY --- # Bring your own credentials > Configure your own OAuth app credentials so users see your brand on consent screens, not Scalekit's. By default, Scalekit uses its own OAuth app credentials when your users go through the OAuth consent flow. This works for development and testing, but in production your users will see Scalekit’s name and branding on the consent screen, not yours. **Bring your own credentials** lets you replace Scalekit’s shared OAuth credentials with your own. Once configured, users see your app name, logo, and terms on every OAuth consent screen. ## What changes when you use your own credentials [Section titled “What changes when you use your own credentials”](#what-changes-when-you-use-your-own-credentials) * **Consent screens** display your application’s name and branding * **Rate limits and quotas** are tied to your OAuth app, not Scalekit’s shared pool * **Provider relationship** is direct, and your OAuth app appears in provider dashboards and audit logs * **Compliance**: useful if your organization requires a direct relationship with each OAuth provider Nothing changes in your code or the Scalekit SDK. The switch is purely a dashboard configuration on the connection. ## Configure your credentials [Section titled “Configure your credentials”](#configure-your-credentials) 1. ### Copy the redirect URI from Scalekit [Section titled “Copy the redirect URI from Scalekit”](#copy-the-redirect-uri-from-scalekit) Go to **AgentKit** > **Connections** and click **Edit** on the connection you want to update. Select **Use your own credentials**. The form expands and displays a **Redirect URI**. Copy it. 2. ### Register your OAuth app with the provider [Section titled “Register your OAuth app with the provider”](#register-your-oauth-app-with-the-provider) In the provider’s developer console, create a new OAuth app (or use an existing one). Add the Redirect URI you copied in the previous step to the list of authorized redirect URIs. Redirect URI must match exactly The URI must match character-for-character. A mismatch will cause OAuth flows to fail with a redirect\_uri\_mismatch error. The provider gives you a **Client ID** and **Client Secret** after registration. Many provider consoles create the app in an internal or development mode by default. That works for your own testing but is not sufficient for customer consent. 3. ### Enter your credentials and save [Section titled “Enter your credentials and save”](#enter-your-credentials-and-save) Back in Scalekit Dashboard, enter the **Client ID** and **Client Secret** from your OAuth app and click **Save**. All new OAuth flows for this connection will now use your credentials. Saving credentials only wires your app into Scalekit. Before customers can connect, promote the app to allow external accounts and validate it end-to-end — see the [AgentKit launch checklist](/agentkit/advanced/launch-checklist/). ## Existing connected accounts [Section titled “Existing connected accounts”](#existing-connected-accounts) Existing connected accounts are not affected immediately Switching credentials does not re-authorize users who are already active. They continue using the previous credentials until they re-authorize. If you need all users to see your branding immediately, generate new authorization links and prompt them to re-authorize. --- # DOCUMENT BOUNDARY --- # Set up a custom domain > Replace the default Scalekit endpoint with your own branded domain using CNAME configuration. Custom domains enable you to offer a fully branded experience. By default, Scalekit assigns a unique endpoint URL, but you can replace it via CNAME configuration. The custom domain also applies to the authorization server URL shown on the OAuth consent screen during MCP authentication; users will see your branded domain instead of the auto-generated `yourapp-xxxx.scalekit.com`. | Before | After | | ------------------------------ | -------------------------- | | `https://yourapp.scalekit.com` | `https://auth.yourapp.com` | * **Environment:** CNAME configuration is available only for production environments * **SSL:** After successful CNAME configuration, an SSL certificate for your custom domain is automatically provisioned ## Set up your custom domain [Section titled “Set up your custom domain”](#set-up-your-custom-domain) ![Scalekit Settings Custom Domain tab showing the subdomain URL field and a CNAME record in the DNS configuration table](/.netlify/images?url=_astro%2F1.BktW9U-H.png\&w=2786\&h=1746\&dpl=6a7afd35ca95e20008d421ee) To set up your custom domain: 1. Go to your domain’s DNS registrar 2. Add a new record to your DNS settings and select **CNAME** as the record type 3. Switch to production environment in the Scalekit dashboard 4. Copy the **Name** (your desired subdomain) from the Scalekit dashboard > Settings > Custom domains and paste it into the **Name/Label/Host** field in your DNS registrar 5. Copy the **Value** from the Scalekit dashboard > Settings > Custom domains and paste it into the **Destination/Target/Value** field in your DNS registrar 6. Save the record in your DNS registrar 7. In the Scalekit dashboard, click **Verify** CNAME record changes can take up to 72 hours to propagate, although they typically happen much sooner. ## Troubleshoot CNAME verification [Section titled “Troubleshoot CNAME verification”](#troubleshoot-cname-verification) If there are any issues during the CNAME verification step: * Double-check your DNS configuration to ensure all values are correctly entered * Once the CNAME changes take effect, Scalekit will automatically provision an SSL certificate for your custom domain. This process can take up to 24 hours You can click on the **Check** button in the Scalekit dashboard to verify SSL certification status. If SSL provisioning takes longer than 24 hours, please contact us at [](mailto:support@scalekit.com) ## DNS registrar guides [Section titled “DNS registrar guides”](#dns-registrar-guides) For detailed instructions on adding a CNAME record in specific registrars: * [GoDaddy: Add a CNAME record](https://www.godaddy.com/en-in/help/add-a-cname-record-19236) * [Namecheap: How to create a CNAME record](https://www.namecheap.com/support/knowledgebase/article.aspx/9646/2237/how-to-create-a-cname-record-for-your-domain) --- # DOCUMENT BOUNDARY --- # AgentKit launch checklist > Verify your AgentKit integration is production-ready before going live. Use this checklist before moving your AgentKit integration to production. ## Environment and credentials [Section titled “Environment and credentials”](#environment-and-credentials) * \[ ] Switch to the production environment in the Scalekit dashboard * \[ ] Set `SCALEKIT_ENV_URL`, `SCALEKIT_CLIENT_ID`, and `SCALEKIT_CLIENT_SECRET` to production values, not dev or staging ## Connections [Section titled “Connections”](#connections) * \[ ] All connectors your agent uses are configured in the production environment * \[ ] Each connection shows as active in the dashboard * \[ ] Connection names used in code match the names in the dashboard exactly ## Connector OAuth apps (if you registered your own app) [Section titled “Connector OAuth apps (if you registered your own app)”](#connector-oauth-apps-if-you-registered-your-own-app) Complete this section for any connector where you registered the OAuth app yourself in the provider’s console. Providers create new OAuth apps in a development or test mode that authorizes only the account that created the app. The connection works while you build and test with your own account, then fails for customer tenants in production — for example, Airtable returns “OAuth app can’t be used outside development,” and ZoomInfo requires a partner application rather than a custom (internal) app for cross-account access. * \[ ] Provider OAuth app is promoted out of development or test mode (published, production, or partner — depending on the provider) so accounts outside your own can authorize * \[ ] Provider app profile is complete where the provider requires it before publishing (logo, terms of service, privacy policy — for example, Airtable Builder Hub) * \[ ] After promoting the app, `client_id`, `client_secret`, redirect URI, and scopes still match between the provider and Scalekit (promotion can rotate the `client_id`) * \[ ] Authorization tested with an account outside the workspace that created the app, not only your own test account ## Authorization and connected accounts [Section titled “Authorization and connected accounts”](#authorization-and-connected-accounts) * \[ ] End-to-end authorization flow tested with a real user account in production * \[ ] Connected accounts created and verified for at least one test user * \[ ] Magic link generation and redirect tested (OAuth connectors) * \[ ] Re-authorization flow tested: verify behavior when a token expires or is revoked ## Security [Section titled “Security”](#security) * \[ ] MCP URLs are generated and consumed server-side only; never passed to or generated in client-side code * \[ ] `identifier` values passed to Tool Proxy are tied to authenticated users, not shared, static, or guessable * \[ ] Session tokens are minted fresh before each agent run and not reused across sessions ## Custom connector (if applicable) [Section titled “Custom connector (if applicable)”](#custom-connector-if-applicable) * \[ ] Connector definition promoted from Dev to Production (see [Create your own connector](/agentkit/bring-your-own-connector/create-connector)) * \[ ] Auth pattern validated with a real connected account in production * \[ ] Tool Proxy calls return expected responses against the production upstream API ## Go live [Section titled “Go live”](#go-live) * \[ ] Custom domain configured and SSL verified (see [Custom domain](/agentkit/advanced/custom-domain)) --- # DOCUMENT BOUNDARY --- # Migrate from Composio to Scalekit > Map Composio concepts to Scalekit AgentKit equivalents and update your agent code step by step. This guide maps Composio concepts to their Scalekit AgentKit equivalents and walks through each migration step: SDK setup, authentication, tool execution, and MCP. Use it as a reference while porting your agent code. ## Concept mapping [Section titled “Concept mapping”](#concept-mapping) | Composio | Scalekit | Notes | | ------------------------------------ | ------------------------------------------ | --------------------------------------------------------------- | | Toolkit (e.g. `GITHUB`) | **Connector** (e.g. `github`) | Scalekit uses lowercase slugs | | Tool (e.g. `GITHUB_CREATE_ISSUE`) | **Tool** (e.g. `github_create_issue`) | Same concept, lowercase naming | | Auth config | **Connection** | OAuth app credentials, scopes, redirect URIs | | Connected account | **Connected account** | Per-user credential record | | `user_id` / entity ID | **`identifier`** | Your app’s unique user ID, passed per API call | | Connect Link | **Authorization link** | OAuth redirect URL for user consent | | Session (`composio.create()`) | No equivalent | Scalekit is stateless — pass `identifier` per call | | Provider package (`composio_openai`) | No equivalent | Scalekit uses a single SDK for all frameworks | | `session.tools()` | `listScopedTools()` | Get tools a user is authorized to call | | `session.tools.execute()` | `executeTool()` | Execute a tool on behalf of a user | | `session.mcp.url` | **Virtual MCP Server URL + session token** | Static server URL with a short-lived bearer token per agent run | | Custom tool (in-memory) | **Custom tool** (API Proxy) | Defined in your app code using `actions.request()` | | `executeToolRequest` (proxy) | `actions.request()` | Proxied REST API call | | Trigger | No equivalent | Scalekit does not support event-driven triggers | | `COMPOSIO_SEARCH_TOOLS` | No equivalent | Use `listScopedTools` with connection name filters | | `COMPOSIO_REMOTE_WORKBENCH` | No equivalent | No remote sandbox execution | ## 1. Set up Scalekit [Section titled “1. Set up Scalekit”](#1-set-up-scalekit) 1. **Create a Scalekit account** Sign up at [app.scalekit.com](https://app.scalekit.com) and copy your API credentials from **Dashboard > Developers > Settings > API Credentials**. 2. **Set environment variables** ```bash 1 SCALEKIT_CLIENT_ID=your_client_id 2 SCALEKIT_CLIENT_SECRET=your_client_secret 3 SCALEKIT_ENV_URL=https://your-env.scalekit.com ``` 3. **Install the SDK** * Python ```bash 1 pip install scalekit-sdk-python ``` * Node.js ```bash 1 npm install @scalekit-sdk/node ``` 4. **Initialize the client** Scalekit uses a single client instance. There is no session object — you pass `identifier` on each API call. * Python ```python 1 import os 2 import scalekit.client 3 4 scalekit_client = scalekit.client.ScalekitClient( 5 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 6 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 ) 9 actions = scalekit_client.actions ``` * Node.js ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node'; 2 3 const scalekit = new ScalekitClient( 4 process.env.SCALEKIT_ENV_URL!, 5 process.env.SCALEKIT_CLIENT_ID!, 6 process.env.SCALEKIT_CLIENT_SECRET! 7 ); ``` ## 2. Configure connections [Section titled “2. Configure connections”](#2-configure-connections) In Composio, auth configs are created programmatically or via the dashboard. In Scalekit, you configure **connections** in the dashboard. For each Composio toolkit your agent uses (Gmail, Slack, GitHub, etc.), create a corresponding connection in **Dashboard > AgentKit > Connections > Add connection**. See [Configure a connection](/agentkit/connections/) for the full walkthrough. | Composio auth type | Scalekit equivalent | | ---------------------------- | ------------------------------------------------------------------ | | OAuth 2.0 (Composio managed) | OAuth 2.0 (use Scalekit credentials to start, then bring your own) | | OAuth 2.0 (custom) | OAuth 2.0 (bring your own credentials) | | API key | API key (user provides during connected account creation) | | Bearer token | Bearer token | | Basic auth | Basic auth | ## 3. Migrate authentication [Section titled “3. Migrate authentication”](#3-migrate-authentication) Both platforms create per-user records (connected accounts) and generate OAuth links. The SDK methods differ. #### Create a connected account and authorize [Section titled “Create a connected account and authorize”](#create-a-connected-account-and-authorize) * Python **Before (Composio):** ```python 1 # Composio handles auth in-chat or via connect link 2 session = composio.create(user_id="user_123") 3 # Auth is triggered automatically when a tool requires it ``` **After (Scalekit):** ```python 1 # Create or retrieve the connected account 2 response = actions.get_or_create_connected_account( 3 connection_name="gmail", 4 identifier="user_123", 5 ) 6 connected_account = response.connected_account 7 8 # Generate an authorization link if the account is not yet active 9 if connected_account.status != "ACTIVE": 10 link_response = actions.get_authorization_link( 11 connection_name="gmail", 12 identifier="user_123", 13 ) 14 auth_url = link_response.link 15 # Redirect or send auth_url to the user ``` * Node.js **Before (Composio):** ```typescript 1 // Composio handles auth in-chat or via connect link 2 const session = await composio.create("user_123"); 3 // Auth is triggered automatically when a tool requires it ``` **After (Scalekit):** ```typescript 1 // Create or retrieve the connected account 2 const response = await scalekit.actions.getOrCreateConnectedAccount({ 3 connectionName: 'gmail', 4 identifier: 'user_123', 5 }); 6 7 const connectedAccount = response.connectedAccount; 8 9 // Generate an authorization link if the account is not yet active 10 if (connectedAccount?.status !== 'ACTIVE') { 11 const linkResponse = await scalekit.actions.getAuthorizationLink({ 12 connectionName: 'gmail', 13 identifier: 'user_123', 14 }); 15 const authUrl = linkResponse.link; 16 // Redirect or send authUrl to the user 17 } ``` **Key difference:** Composio can trigger auth in-chat automatically. With Scalekit, your app explicitly creates the connected account and sends the authorization link to the user. Once the user completes the OAuth flow, the connected account becomes `ACTIVE` and your agent can execute tools. #### Check connected account status [Section titled “Check connected account status”](#check-connected-account-status) Composio tracks two statuses (`ACTIVE` and `INACTIVE`). Scalekit uses more granular states: | Scalekit status | Meaning | | --------------- | -------------------------------------------------------------- | | `PENDING` | User hasn’t completed authentication | | `ACTIVE` | Credentials valid, ready for tool calls | | `EXPIRED` | Credentials expired or invalidated, re-authentication required | | `REVOKED` | User revoked access or credentials were invalidated | | `ERROR` | Authentication or configuration error | Check status before executing tools. If the account is not `ACTIVE`, generate a new authorization link. ## 4. Migrate tool calls [Section titled “4. Migrate tool calls”](#4-migrate-tool-calls) #### List available tools [Section titled “List available tools”](#list-available-tools) * Python **Before (Composio):** ```python 1 session = composio.create(user_id="user_123") 2 tools = session.tools() # all tools the user is authorized for ``` **After (Scalekit):** ```python 1 tools_response = scalekit_client.actions.tools.list_scoped_tools( 2 identifier="user_123", 3 filter={"connection_names": ["gmail"]}, # optional; omit for all connectors 4 page_size=100, 5 ) ``` * Node.js **Before (Composio):** ```typescript 1 const session = await composio.create("user_123"); 2 const tools = await session.tools(); // all tools the user is authorized for ``` **After (Scalekit):** ```typescript 1 const { tools } = await scalekit.tools.listScopedTools('user_123', { 2 filter: { connectionNames: ['gmail'] }, // optional; omit for all connectors 3 pageSize: 100, 4 }); ``` #### Execute a tool [Section titled “Execute a tool”](#execute-a-tool) * Python **Before (Composio):** ```python 1 session = composio.create(user_id="user_123") 2 tools = session.tools() 3 # Framework handles execution via the agent loop, or: 4 # composio.tools.execute(tool_name="GMAIL_FETCH_MAILS", params={...}) ``` **After (Scalekit):** ```python 1 result = actions.execute_tool( 2 tool_name="gmail_fetch_mails", 3 identifier="user_123", 4 connection_name="gmail", 5 tool_input={"query": "is:unread", "max_results": 5}, 6 ) 7 print(result.data) ``` * Node.js **Before (Composio):** ```typescript 1 const session = await composio.create("user_123"); 2 const tools = await session.tools(); 3 // Framework handles execution via the agent loop ``` **After (Scalekit):** ```typescript 1 const result = await scalekit.actions.executeTool({ 2 toolName: 'gmail_fetch_mails', 3 identifier: 'user_123', 4 connectionName: 'gmail', 5 toolInput: { query: 'is:unread', max_results: 5 }, 6 }); 7 console.log(result.data); ``` **Key differences:** * Composio tool names are uppercase (`GMAIL_FETCH_MAILS`); Scalekit uses lowercase (`gmail_fetch_mails`) * Composio’s session model means you don’t pass `user_id` on each call. With Scalekit, pass `identifier` and `connection_name` on every `executeTool` call * Both return structured, LLM-ready output ### Map tool names [Section titled “Map tool names”](#map-tool-names) Composio and Scalekit may name tools differently for the same connector. Browse the connector’s tool list in the [Scalekit connector catalog](/agentkit/connectors/) to find the exact tool names. Common patterns: | Composio tool name | Scalekit tool name | | --------------------- | --------------------- | | `GMAIL_FETCH_MAILS` | `gmail_fetch_mails` | | `SLACK_SEND_MESSAGE` | `slack_send_message` | | `GITHUB_CREATE_ISSUE` | `github_create_issue` | | `NOTION_CREATE_PAGE` | `notion_create_page` | Tool input schemas may also differ. Check each tool’s parameters in the connector catalog and update your agent’s tool input accordingly. ## 5. Migrate MCP [Section titled “5. Migrate MCP”](#5-migrate-mcp) Both platforms support MCP (Model Context Protocol) for framework-agnostic tool discovery and execution. **Before (Composio):** ```json 1 { 2 "mcpServers": { 3 "composio": { 4 "url": "https://backend.composio.dev/v3/mcp/{SERVER_ID}?user_id={USER_ID}", 5 "headers": { 6 "x-api-key": "" 7 } 8 } 9 } 10 } ``` **After (Scalekit):** Scalekit MCP uses Virtual MCP Servers: 1. **Create an MCP config** — define which connections and tools the server exposes (one-time). This gives you a static `mcp_server_url`. 2. **Mint a session token** — before each agent run, call `create_session_token` for the user. Pass it as a bearer auth header. See [Virtual MCP Servers](/agentkit/mcp/overview/) for the full setup. ```json 1 { 2 "mcpServers": { 3 "scalekit": { 4 "url": "", 5 "headers": { 6 "Authorization": "Bearer " 7 } 8 } 9 } 10 } ``` **Key difference:** Composio embeds the user ID in the URL. Scalekit uses a static server URL shared across all users, with a short-lived session token per agent run for authentication. ## 6. Migrate custom tools [Section titled “6. Migrate custom tools”](#6-migrate-custom-tools) In Composio, custom tools are defined in code with decorators and stored in memory — they’re lost on restart. In Scalekit, custom tools use **API Proxy mode** (`actions.request`). The proxy is available out of the box for every connector with no extra configuration. You define the tool contract in your application code and call the provider’s REST endpoint through Scalekit, which injects the user’s credentials automatically. | Composio approach | Scalekit approach | | ------------------------------------------------ | -------------------------------------------------------------- | | `@composio.tools.custom_tool` decorator | Define the tool in your app code | | In-memory, lost on restart | Lives in your codebase | | `executeToolRequest` for authenticated API calls | `actions.request()` — works out of the box for every connector | * Python ```python 1 response = actions.request( 2 connection_name="gmail", 3 identifier="user_123", 4 method="GET", 5 path="/gmail/v1/users/me/messages", 6 ) ``` * Node.js ```typescript 1 const response = await scalekit.actions.request({ 2 connectionName: 'gmail', 3 identifier: 'user_123', 4 method: 'GET', 5 path: '/gmail/v1/users/me/messages', 6 }); ``` ## 7. Add custom connectors [Section titled “7. Add custom connectors”](#7-add-custom-connectors) If your agent connects to an API or MCP server that isn’t in Scalekit’s built-in catalog, you can add your own connector. Custom connectors support OAuth 2.0, API keys, bearer tokens, and other auth types. Once created, they work exactly like built-in connectors — same connected account flow, same `actions.request()` proxy, same MCP tool calling. This goes beyond what Composio offers with in-memory custom tools: Scalekit custom connectors are persistent, support any SaaS API, partner system, or internal service, and keep all credential handling centralized. See [Add your own connector](/agentkit/bring-your-own-connector/overview/) for the full walkthrough. ## Checklist [Section titled “Checklist”](#checklist) * \[ ] Scalekit account created, API credentials saved as environment variables * \[ ] Scalekit SDK installed * \[ ] Connections created in the Scalekit Dashboard for each connector * \[ ] Connected account creation and authorization link flow ported * \[ ] Tool names updated from uppercase to lowercase * \[ ] `executeTool` calls updated with `identifier` and `connection_name` * \[ ] Tool input schemas verified against the Scalekit connector catalog * \[ ] MCP config created and session token flow implemented (if using MCP) * \[ ] Custom tools ported to `actions.request()` (if applicable) * \[ ] Agent tested end-to-end with a test user * \[ ] Users re-authorized through Scalekit’s OAuth flow --- # DOCUMENT BOUNDARY --- # Proxy API Calls > Use Scalekit managed authentication and make direct HTTP calls to third party applications Even though Scalekit Agent Auth offers pre-built connector tools out of the box for the supported applications, if you would like to make direct API calls to the third party applications for any custom behaviour, you can leverage proxy\_api tool to directly invoke the third party application. Based on the connected account or user identifier details, Scalekit will automatically inject the user authorization tokens so that API calls to the third application will be successful. Proxy must be enabled per environment Proxy access for built-in providers (Gmail, Notion, Slack, and others) is **not enabled by default** on new environments. If you receive the error `proxy not enabled for provider`, contact to enable the proxy for your environment. ```python 1 # Fetch recent emails 2 emails = actions.tools.execute( 3 connected_account_id=connected_account.id, 4 tool='gmail_proxy_api', 5 parameters={ 6 'path': '/gmail/v1/users/me/messages', 7 'method': 'GET', 8 'headers': [{'Content-Type': 'application/json'}], 9 'params': [{'max_results': '5'}], 10 'body': '' #actual JSON payload 11 } 12 ) 13 14 print(f'Recent emails: {emails.result}') ``` As part of the above execution, Scalekit will automatically inject Bearer token in the request header before making the API call to GMAIL. ## Common scenarios [Section titled “Common scenarios”](#common-scenarios) --- # DOCUMENT BOUNDARY --- # Authentication Methods Comparison > Compare different authentication methods supported by AgentKit including OAuth 2.0, API Keys, Bearer Tokens, and Custom JWT to choose the right approach. AgentKit supports multiple authentication methods to connect with third-party providers. This guide helps you understand the differences and choose the right authentication method for your use case. ## Authentication methods overview [Section titled “Authentication methods overview”](#authentication-methods-overview) OAuth 2.0 **Most secure and widely supported** User-delegated authentication with automatic token refresh and granular permissions. **Best for:** Google, Microsoft, Slack, GitHub API Keys **Simple static credentials** Provider-issued keys for straightforward server-to-server authentication. **Best for:** Jira, Asana, Linear, Airtable Bearer Tokens **User-generated tokens** Personal access tokens with scoped permissions for individual use. **Best for:** GitHub PATs, GitLab tokens Custom JWT **Advanced signed tokens** Cryptographically signed tokens for service accounts and custom protocols. **Best for:** Custom integrations, service accounts ## Comparison matrix [Section titled “Comparison matrix”](#comparison-matrix) | Feature | OAuth 2.0 | API Keys | Bearer Tokens | Custom JWT | | ------------------------ | ---------- | -------- | ------------- | ------------ | | **Security Level** | High | Medium | Medium | High | | **User Interaction** | Required | Optional | Required | Not required | | **Token Refresh** | Automatic | N/A | Manual | Varies | | **Setup Complexity** | Moderate | Easy | Easy | Complex | | **Granular Permissions** | Yes | Limited | Yes | Limited | | **Provider Support** | Widespread | Common | Common | Limited | ## When to use each method [Section titled “When to use each method”](#when-to-use-each-method) ### OAuth 2.0 [Section titled “OAuth 2.0”](#oauth-20) **Use when:** * Provider supports OAuth * Acting on behalf of users * Need automatic token refresh * Require granular permissions * Building user-facing applications **Example:** User connects Gmail to send emails through your app ### API Keys [Section titled “API Keys”](#api-keys) **Use when:** * Provider only supports API keys * Building internal tools * Server-to-server communication * Simplicity is priority **Example:** Automated Jira ticket creation for support system ### Bearer Tokens [Section titled “Bearer Tokens”](#bearer-tokens) **Use when:** * Personal access is sufficient * Building developer tools * OAuth unavailable * User prefers manual control **Example:** Personal GitHub repository automation ### Custom JWT [Section titled “Custom JWT”](#custom-jwt) **Use when:** * Provider requires JWT * Service account access needed * Custom authentication protocol * Advanced security requirements **Example:** Enterprise service account integrations ## Next steps [Section titled “Next steps”](#next-steps) * [Connectors](/agentkit/connectors) - Available third-party providers * [Connections](/agentkit/connections) - Configure provider connections * [Authorization Methods](/agentkit/tools/authorize) - Detailed authentication implementation --- # DOCUMENT BOUNDARY --- # Testing Authentication Flows > Learn how to test AgentKit authentication flows in development, staging, and production environments with comprehensive testing strategies. Thorough testing of authentication flows ensures your AgentKit integration works reliably before production deployment. This guide covers testing strategies, tools, and best practices. ## Testing environments [Section titled “Testing environments”](#testing-environments) ### Development environment [Section titled “Development environment”](#development-environment) **Purpose:** Rapid iteration and debugging **Characteristics:** * Local development server * Test accounts and credentials * Verbose logging enabled * Quick feedback loops **Setup:** development.env ```python 1 SCALEKIT_ENV_URL=https://your-env.scalekit.dev 2 SCALEKIT_CLIENT_ID=dev_client_id 3 SCALEKIT_CLIENT_SECRET=dev_client_secret 4 DEBUG=true 5 LOG_LEVEL=debug ``` ### Staging environment [Section titled “Staging environment”](#staging-environment) **Purpose:** Pre-production validation **Characteristics:** * Production-like configuration * Realistic data volumes * Integration with staging third-party accounts * Performance testing **Setup:** staging.env ```python 1 SCALEKIT_ENV_URL=https://your-env.scalekit.cloud 2 SCALEKIT_CLIENT_ID=staging_client_id 3 SCALEKIT_CLIENT_SECRET=staging_client_secret 4 DEBUG=false 5 LOG_LEVEL=info ``` ### Production environment [Section titled “Production environment”](#production-environment) **Purpose:** Live user traffic **Characteristics:** * Real user data * Verified OAuth applications * Monitoring and alerts * Minimal logging **Setup:** production.env ```python 1 SCALEKIT_ENV_URL=https://your-env.scalekit.cloud 2 SCALEKIT_CLIENT_ID=prod_client_id 3 SCALEKIT_CLIENT_SECRET=prod_client_secret 4 DEBUG=false 5 LOG_LEVEL=warn ``` ## Test account setup [Section titled “Test account setup”](#test-account-setup) ### Creating test providers [Section titled “Creating test providers”](#creating-test-providers) Set up test accounts for each provider: **Google Workspace:** 1. Create test Google account 2. Enable 2FA if testing MFA scenarios 3. Use for Gmail, Calendar, Drive testing **Slack:** 1. Create free Slack workspace 2. Install your Slack app 3. Use for messaging and notification testing **Microsoft 365:** 1. Get Microsoft 365 developer account (free) 2. Create test users 3. Use for Outlook, Teams, OneDrive testing **Jira/Atlassian:** 1. Create free Atlassian Cloud account 2. Set up test projects 3. Generate API tokens for testing ### Test user patterns [Section titled “Test user patterns”](#test-user-patterns) Create different test users for scenarios: ```python 1 # Test user configurations 2 TEST_USERS = { 3 "basic_user": { 4 "identifier": "test_user_001", 5 "providers": ["gmail"], 6 "scenario": "Single provider, basic authentication" 7 }, 8 "power_user": { 9 "identifier": "test_user_002", 10 "providers": ["gmail", "slack", "jira", "calendar"], 11 "scenario": "Multiple providers, full feature access" 12 }, 13 "expired_user": { 14 "identifier": "test_user_003", 15 "providers": ["gmail"], 16 "scenario": "Expired tokens, test refresh logic", 17 "setup": "Manually expire tokens" 18 }, 19 "revoked_user": { 20 "identifier": "test_user_004", 21 "providers": ["slack"], 22 "scenario": "User revoked access, test re-auth flow" 23 } 24 } ``` ## Unit testing authentication [Section titled “Unit testing authentication”](#unit-testing-authentication) ### Test connected account creation [Section titled “Test connected account creation”](#test-connected-account-creation) * Python ```python 1 import unittest 2 from unittest.mock import Mock, patch 3 4 class TestConnectedAccountCreation(unittest.TestCase): 5 def setUp(self): 6 self.actions = Mock() 7 self.user_id = "test_user_123" 8 self.provider = "gmail" 9 10 def test_create_connected_account_success(self): 11 """Test successful connected account creation""" 12 # Mock response 13 mock_response = Mock() 14 mock_response.connected_account = Mock( 15 id="account_123", 16 status="PENDING", 17 connection_name="gmail" 18 ) 19 self.actions.get_or_create_connected_account.return_value = mock_response 20 21 # Execute 22 response = self.actions.get_or_create_connected_account( 23 connection_name=self.provider, 24 identifier=self.user_id 25 ) 26 27 # Assert 28 self.assertEqual(response.connected_account.status, "PENDING") 29 self.assertEqual(response.connected_account.connection_name, "gmail") 30 31 def test_generate_authorization_link(self): 32 """Test authorization link generation""" 33 mock_response = Mock() 34 mock_response.link = "https://accounts.google.com/oauth/authorize?..." 35 36 self.actions.get_authorization_link.return_value = mock_response 37 38 response = self.actions.get_authorization_link( 39 connection_name=self.provider, 40 identifier=self.user_id 41 ) 42 43 self.assertIn("https://", response.link) 44 self.actions.get_authorization_link.assert_called_once() 45 46 if __name__ == '__main__': 47 unittest.main() ``` * Node.js ```javascript 1 const { describe, it, expect, jest, beforeEach } = require('@jest/globals'); 2 3 describe('Connected Account Creation', () => { 4 let mockActions; 5 const userId = 'test_user_123'; 6 const provider = 'gmail'; 7 8 beforeEach(() => { 9 mockActions = { 10 getOrCreateConnectedAccount: jest.fn(), 11 getAuthorizationLink: jest.fn() 12 }; 13 }); 14 15 it('should create connected account successfully', async () => { 16 // Mock response 17 const mockResponse = { 18 connectedAccount: { 19 id: 'account_123', 20 status: 'PENDING', 21 connectionName: 'gmail' 22 } 23 }; 24 25 mockActions.getOrCreateConnectedAccount.mockResolvedValue(mockResponse); 26 27 // Execute 28 const response = await mockActions.getOrCreateConnectedAccount({ 29 connectionName: provider, 30 identifier: userId 31 }); 32 33 // Assert 34 expect(response.connectedAccount.status).toBe('PENDING'); 35 expect(response.connectedAccount.connectionName).toBe('gmail'); 36 }); 37 38 it('should generate authorization link', async () => { 39 const mockResponse = { 40 link: 'https://accounts.google.com/oauth/authorize?...' 41 }; 42 43 mockActions.getAuthorizationLink.mockResolvedValue(mockResponse); 44 45 const response = await mockActions.getAuthorizationLink({ 46 connectionName: provider, 47 identifier: userId 48 }); 49 50 expect(response.link).toContain('https://'); 51 expect(mockActions.getAuthorizationLink).toHaveBeenCalledTimes(1); 52 }); 53 }); ``` * Go ```go 1 package auth_test 2 3 import ( 4 "testing" 5 "github.com/stretchr/testify/assert" 6 "github.com/stretchr/testify/mock" 7 ) 8 9 type MockActions struct { 10 mock.Mock 11 } 12 13 func (m *MockActions) GetOrCreateConnectedAccount(connectionName, identifier string) (*ConnectedAccountResponse, error) { 14 args := m.Called(connectionName, identifier) 15 return args.Get(0).(*ConnectedAccountResponse), args.Error(1) 16 } 17 18 func TestCreateConnectedAccount(t *testing.T) { 19 // Arrange 20 mockActions := new(MockActions) 21 userId := "test_user_123" 22 provider := "gmail" 23 24 expectedResponse := &ConnectedAccountResponse{ 25 ConnectedAccount: ConnectedAccount{ 26 ID: "account_123", 27 Status: "PENDING", 28 ConnectionName: "gmail", 29 }, 30 } 31 32 mockActions.On("GetOrCreateConnectedAccount", provider, userId). 33 Return(expectedResponse, nil) 34 35 // Act 36 response, err := mockActions.GetOrCreateConnectedAccount(provider, userId) 37 38 // Assert 39 assert.NoError(t, err) 40 assert.Equal(t, "PENDING", response.ConnectedAccount.Status) 41 assert.Equal(t, "gmail", response.ConnectedAccount.ConnectionName) 42 mockActions.AssertExpectations(t) 43 } ``` * Java ```java 1 import org.junit.jupiter.api.BeforeEach; 2 import org.junit.jupiter.api.Test; 3 import org.mockito.Mock; 4 import org.mockito.MockitoAnnotations; 5 import static org.junit.jupiter.api.Assertions.*; 6 import static org.mockito.Mockito.*; 7 8 class ConnectedAccountCreationTest { 9 @Mock 10 private Actions mockActions; 11 12 private String userId; 13 private String provider; 14 15 @BeforeEach 16 void setUp() { 17 MockitoAnnotations.openMocks(this); 18 userId = "test_user_123"; 19 provider = "gmail"; 20 } 21 22 @Test 23 void testCreateConnectedAccountSuccess() { 24 // Arrange 25 ConnectedAccount account = new ConnectedAccount(); 26 account.setId("account_123"); 27 account.setStatus("PENDING"); 28 account.setConnectionName("gmail"); 29 30 ConnectedAccountResponse mockResponse = new ConnectedAccountResponse(); 31 mockResponse.setConnectedAccount(account); 32 33 when(mockActions.getOrCreateConnectedAccount(provider, userId)) 34 .thenReturn(mockResponse); 35 36 // Act 37 ConnectedAccountResponse response = mockActions 38 .getOrCreateConnectedAccount(provider, userId); 39 40 // Assert 41 assertEquals("PENDING", response.getConnectedAccount().getStatus()); 42 assertEquals("gmail", response.getConnectedAccount().getConnectionName()); 43 verify(mockActions, times(1)).getOrCreateConnectedAccount(provider, userId); 44 } 45 } ``` ### Test token refresh logic [Section titled “Test token refresh logic”](#test-token-refresh-logic) ```python 1 def test_token_refresh_scenarios(self): 2 """Test various token refresh scenarios""" 3 test_cases = [ 4 { 5 "name": "successful_refresh", 6 "initial_status": "EXPIRED", 7 "expected_status": "ACTIVE", 8 "should_succeed": True 9 }, 10 { 11 "name": "refresh_token_invalid", 12 "initial_status": "EXPIRED", 13 "expected_status": "EXPIRED", 14 "should_succeed": False 15 }, 16 { 17 "name": "already_active", 18 "initial_status": "ACTIVE", 19 "expected_status": "ACTIVE", 20 "should_succeed": True 21 } 22 ] 23 24 for case in test_cases: 25 with self.subTest(case=case["name"]): 26 # Setup mock 27 mock_account = Mock() 28 mock_account.status = case["expected_status"] 29 30 if case["should_succeed"]: 31 self.actions.refresh_connected_account.return_value = mock_account 32 else: 33 self.actions.refresh_connected_account.side_effect = Exception("Refresh failed") 34 35 # Execute 36 try: 37 result = self.actions.refresh_connected_account( 38 identifier="test_user", 39 connection_name="gmail" 40 ) 41 success = True 42 except Exception: 43 success = False 44 45 # Assert 46 self.assertEqual(success, case["should_succeed"]) ``` ## Integration testing [Section titled “Integration testing”](#integration-testing) ### Test complete authentication flow [Section titled “Test complete authentication flow”](#test-complete-authentication-flow) ```python 1 import time 2 3 def test_complete_oauth_flow_integration(): 4 """ 5 Integration test for complete OAuth authentication flow. 6 Requires manual intervention for OAuth consent. 7 """ 8 user_id = "integration_test_user" 9 provider = "gmail" 10 11 # Step 1: Create connected account 12 print("Step 1: Creating connected account...") 13 response = actions.get_or_create_connected_account( 14 connection_name=provider, 15 identifier=user_id 16 ) 17 18 account = response.connected_account 19 assert account.status == "PENDING", f"Expected PENDING, got {account.status}" 20 print(f"✓ Connected account created: {account.id}") 21 22 # Step 2: Generate authorization link 23 print("\nStep 2: Generating authorization link...") 24 link_response = actions.get_authorization_link( 25 connection_name=provider, 26 identifier=user_id 27 ) 28 29 print(f"✓ Authorization link: {link_response.link}") 30 print("\n⚠ MANUAL STEP: Open this link in a browser and complete OAuth") 31 print(" Press Enter after completing OAuth flow...") 32 input() 33 34 # Step 3: Verify account is now active 35 print("\nStep 3: Verifying account status...") 36 time.sleep(2) # Brief delay for processing 37 38 account = actions.get_connected_account( 39 identifier=user_id, 40 connection_name=provider 41 ) 42 43 assert account.status == "ACTIVE", f"Expected ACTIVE, got {account.status}" 44 print(f"✓ Account is ACTIVE") 45 print(f" Granted scopes: {account.scopes}") 46 47 # Step 4: Test tool execution 48 print("\nStep 4: Testing tool execution...") 49 result = actions.execute_tool( 50 identifier=user_id, 51 tool_name="gmail_get_profile", 52 tool_input={} 53 ) 54 55 assert result is not None, "Tool execution failed" 56 print(f"✓ Tool executed successfully") 57 58 print("\n✓✓✓ Integration test completed successfully") 59 60 # Run with: pytest test_auth_integration.py -s (to see output) ``` ### Test error scenarios [Section titled “Test error scenarios”](#test-error-scenarios) ```python 1 def test_error_scenarios(): 2 """Test various error scenarios""" 3 user_id = "error_test_user" 4 5 # Test 1: Invalid provider 6 print("Test 1: Invalid provider...") 7 try: 8 actions.get_or_create_connected_account( 9 connection_name="invalid_provider", 10 identifier=user_id 11 ) 12 assert False, "Should have raised error" 13 except Exception as e: 14 print(f"✓ Caught expected error: {type(e).__name__}") 15 16 # Test 2: Execute tool without authentication 17 print("\nTest 2: Tool execution without auth...") 18 try: 19 actions.execute_tool( 20 identifier="nonexistent_user", 21 tool_name="gmail_send_email", 22 tool_input={"to": "test@example.com"} 23 ) 24 assert False, "Should have raised error" 25 except Exception as e: 26 print(f"✓ Caught expected error: {type(e).__name__}") 27 28 # Test 3: Missing required scopes 29 print("\nTest 3: Missing required scopes...") 30 # This test requires setup with insufficient scopes 31 print("⚠ Skipped: Requires special setup") 32 33 print("\n✓✓✓ Error scenario tests completed") ``` ## Automated testing [Section titled “Automated testing”](#automated-testing) ### Test authentication in CI/CD [Section titled “Test authentication in CI/CD”](#test-authentication-in-cicd) .github/workflows/test-auth.yml ```yaml 1 name: Test Authentication Flows 2 3 on: [push, pull_request] 4 5 jobs: 6 test: 7 runs-on: ubuntu-latest 8 9 steps: 10 - uses: actions/checkout@v2 11 12 - name: Set up Python 13 uses: actions/setup-python@v2 14 with: 15 python-version: '3.9' 16 17 - name: Install dependencies 18 run: | 19 pip install -r requirements.txt 20 pip install pytest pytest-cov 21 22 - name: Run unit tests 23 env: 24 SCALEKIT_CLIENT_ID: ${{ secrets.TEST_CLIENT_ID }} 25 SCALEKIT_CLIENT_SECRET: ${{ secrets.TEST_CLIENT_SECRET }} 26 SCALEKIT_ENV_URL: ${{ secrets.TEST_ENV_URL }} 27 run: | 28 pytest tests/test_auth.py -v --cov=src/auth 29 30 - name: Run integration tests (non-OAuth) 31 env: 32 SCALEKIT_CLIENT_ID: ${{ secrets.TEST_CLIENT_ID }} 33 SCALEKIT_CLIENT_SECRET: ${{ secrets.TEST_CLIENT_SECRET }} 34 SCALEKIT_ENV_URL: ${{ secrets.TEST_ENV_URL }} 35 run: | 36 pytest tests/test_auth_integration.py -v -k "not oauth" ``` ### Mock OAuth flows [Section titled “Mock OAuth flows”](#mock-oauth-flows) ```python 1 from unittest.mock import patch, Mock 2 3 def test_oauth_flow_with_mocks(): 4 """Test OAuth flow with mocked responses (no actual OAuth)""" 5 6 with patch('scalekit.actions.get_or_create_connected_account') as mock_create, \ 7 patch('scalekit.actions.get_authorization_link') as mock_link, \ 8 patch('scalekit.actions.get_connected_account') as mock_get: 9 10 # Mock connected account creation 11 mock_account = Mock() 12 mock_account.id = "account_123" 13 mock_account.status = "PENDING" 14 15 mock_response = Mock() 16 mock_response.connected_account = mock_account 17 mock_create.return_value = mock_response 18 19 # Mock authorization link 20 mock_link_response = Mock() 21 mock_link_response.link = "https://mock-oauth-url.com" 22 mock_link.return_value = mock_link_response 23 24 # Mock successful authentication (simulate user completing OAuth) 25 mock_account.status = "ACTIVE" 26 mock_account.scopes = ["gmail.readonly", "gmail.send"] 27 mock_get.return_value = mock_account 28 29 # Test the flow 30 # 1. Create account 31 response = mock_create(connection_name="gmail", identifier="user_123") 32 assert response.connected_account.status == "PENDING" 33 34 # 2. Get auth link 35 link = mock_link(connection_name="gmail", identifier="user_123") 36 assert "https://" in link.link 37 38 # 3. Simulate user completing OAuth (status changes to ACTIVE) 39 account = mock_get(identifier="user_123", connection_name="gmail") 40 assert account.status == "ACTIVE" 41 assert len(account.scopes) > 0 42 43 print("✓ OAuth flow test with mocks completed") ``` ## Performance testing [Section titled “Performance testing”](#performance-testing) ### Test token refresh performance [Section titled “Test token refresh performance”](#test-token-refresh-performance) ```python 1 import time 2 3 def test_token_refresh_performance(): 4 """Measure token refresh latency""" 5 user_id = "perf_test_user" 6 provider = "gmail" 7 8 # Setup: Create account with expired token 9 # (This requires manually setting up an expired account) 10 11 iterations = 10 12 refresh_times = [] 13 14 for i in range(iterations): 15 start_time = time.time() 16 17 try: 18 actions.refresh_connected_account( 19 identifier=user_id, 20 connection_name=provider 21 ) 22 elapsed = time.time() - start_time 23 refresh_times.append(elapsed) 24 print(f"Iteration {i+1}: {elapsed:.3f}s") 25 except Exception as e: 26 print(f"Iteration {i+1} failed: {e}") 27 28 if refresh_times: 29 avg_time = sum(refresh_times) / len(refresh_times) 30 min_time = min(refresh_times) 31 max_time = max(refresh_times) 32 33 print(f"\nToken Refresh Performance:") 34 print(f" Average: {avg_time:.3f}s") 35 print(f" Min: {min_time:.3f}s") 36 print(f" Max: {max_time:.3f}s") 37 38 # Assert reasonable performance (adjust threshold as needed) 39 assert avg_time < 2.0, f"Average refresh time too slow: {avg_time:.3f}s" ``` ## Best practices [Section titled “Best practices”](#best-practices) ### Test checklist [Section titled “Test checklist”](#test-checklist) 1. **Unit tests** - Test individual authentication functions 2. **Integration tests** - Test complete OAuth flows 3. **Error handling** - Test all error scenarios 4. **Token refresh** - Test automatic and manual refresh 5. **Multi-provider** - Test multiple simultaneous connections 6. **Performance** - Measure and optimize latency 7. **Security** - Verify token encryption and secure storage ### Testing dos and don’ts [Section titled “Testing dos and don’ts”](#testing-dos-and-donts) ✅ **Do:** * Use separate test accounts for each provider * Test both success and failure scenarios * Mock external OAuth calls in unit tests * Test token refresh before expiration * Verify error messages are helpful * Test with realistic data volumes ❌ **Don’t:** * Use production accounts for testing * Hardcode test credentials in source code * Skip error scenario testing * Assume OAuth always succeeds * Neglect performance testing * Test only happy path scenarios ### Security testing [Section titled “Security testing”](#security-testing) ```python 1 def test_security_scenarios(): 2 """Test security-related authentication scenarios""" 3 4 # Test 1: Verify tokens are not exposed in logs 5 print("Test 1: Token exposure check...") 6 with patch('logging.Logger.debug') as mock_log: 7 account = actions.get_connected_account( 8 identifier="test_user", 9 connection_name="gmail" 10 ) 11 12 # Verify no access tokens in log calls 13 for call in mock_log.call_args_list: 14 log_message = str(call) 15 assert "access_token" not in log_message.lower() 16 assert "refresh_token" not in log_message.lower() 17 18 print("✓ No tokens in logs") 19 20 # Test 2: Verify HTTPS for OAuth redirects 21 print("\nTest 2: HTTPS verification...") 22 link_response = actions.get_authorization_link( 23 connection_name="gmail", 24 identifier="test_user" 25 ) 26 27 assert link_response.link.startswith("https://") 28 print("✓ OAuth uses HTTPS") 29 30 # Test 3: State parameter validation 31 print("\nTest 3: State parameter present...") 32 assert "state=" in link_response.link 33 print("✓ State parameter included") 34 35 print("\n✓✓✓ Security tests completed") ``` ## Next steps [Section titled “Next steps”](#next-steps) * [Troubleshoot connection errors](/agentkit/authentication/troubleshooting) — Debug connection and tool call issues * [Manage connected accounts](/agentkit/connected-accounts/) — Test multiple connections per user --- # DOCUMENT BOUNDARY --- # Troubleshoot connection errors > Diagnose connection failures, connected account issues, and tool execution errors in AgentKit. Use this guide when a connection fails during OAuth, a connected account shows an unexpected status, or a tool call fails. Start with the diagnostics below, then open the matching scenario. For connection setup errors (redirect URI mismatch, session expiry, token exchange failures), also see [Common scenarios on Configure connections](/agentkit/connections/#common-scenarios). ## Start with diagnostics [Section titled “Start with diagnostics”](#start-with-diagnostics) Check the connected account status first. That tells you whether the user never finished OAuth, still needs identity verification, tokens expired, or the account is disconnected. * Python ```python 1 account = scalekit_client.actions.get_connected_account( 2 identifier="user_123", 3 connection_name="github-connect", 4 ) 5 6 print(account.status) # ACTIVE, EXPIRED, PENDING_AUTH, PENDING_VERIFICATION, or DISCONNECTED 7 print(account.scopes) ``` * Node.js ```typescript 1 const account = await scalekit.actions.getConnectedAccount({ 2 identifier: 'user_123', 3 connectionName: 'github-connect', 4 }); 5 6 console.log(account.status); // ACTIVE, EXPIRED, PENDING_AUTH, PENDING_VERIFICATION, or DISCONNECTED 7 console.log(account.scopes); ``` | Status | Meaning | | ---------------------- | ---------------------------------------------------------------- | | `ACTIVE` | Credentials are valid; tool calls should work | | `EXPIRED` | Access token expired and needs refresh or re-authentication | | `PENDING_AUTH` | User has not finished OAuth, or re-authentication is in progress | | `PENDING_VERIFICATION` | OAuth succeeded; user identity verification is still required | | `DISCONNECTED` | Account was manually disconnected | If status is `ACTIVE` but a tool still fails, run a read-only tool (for example `github_user_get_authenticated`) to confirm the connection end to end. The error message usually points to scopes, credentials, or provider rate limits. To catch status changes without polling, subscribe to `connected_account.status_updated`. For automatic refresh failures, also subscribe to `connected_account.token_refresh_failed`. See [Detect when re-authentication is needed](/agentkit/connected-accounts/#detect-when-re-authentication-is-needed) for payload details and filtering. ## Connected account status [Section titled “Connected account status”](#connected-account-status) ## OAuth flow errors [Section titled “OAuth flow errors”](#oauth-flow-errors) ## Tool execution failures [Section titled “Tool execution failures”](#tool-execution-failures) ## Provider-specific errors [Section titled “Provider-specific errors”](#provider-specific-errors) ## Configuration and rate limits [Section titled “Configuration and rate limits”](#configuration-and-rate-limits) ## Get help [Section titled “Get help”](#get-help) Open **AgentKit** > **Connected Accounts** in the dashboard and review status, refresh history, and tool execution logs for the affected account. When you contact [support](mailto:support@scalekit.com), include: * Connected account ID or user `identifier` * Connection name (for example `github-connect`, `slack`) * Full error text and timestamp * Steps that reproduce the failure Related guides: * [Configure connections](/agentkit/connections/) — setup, scopes, and common OAuth errors * [Manage connected accounts](/agentkit/connected-accounts/) — per-user connection state and credentials --- # DOCUMENT BOUNDARY --- # Create your own connector > Choose an auth type, build the connector payload, and create or manage custom connectors in Scalekit. Create a custom connector to bring an unsupported API or MCP server into Scalekit’s secure access model. This guide walks you through building the connector payload, creating the connector, and managing it over its lifecycle - list, update, and delete - with the management API. [Check out the examples](https://github.com/scalekit-inc/python-connect-demos/tree/main/custom-connectors) ## Create a connector [Section titled “Create a connector”](#create-a-connector) Create a connector in the Scalekit Dashboard or with the management API. The dashboard provides a guided form for MCP connectors; the management API gives you scriptable control over every connector type and auth pattern. ### Create an MCP connector in the dashboard [Section titled “Create an MCP connector in the dashboard”](#create-an-mcp-connector-in-the-dashboard) Add an MCP connector through a guided form - no payload required. 1. In the Scalekit Dashboard, switch to **AgentKit**. 2. Select **Connectors**. 3. Select **Create custom connector**. 4. Complete the **Add MCP connector** form: * **Display name**: a name for the connector, such as `Example MCP`. * **Description**: a short description of what the connector connects to. * **Icon URL** (optional): an icon for the connector. Must start with `https://`. For best results, use an 800×800px SVG image, such as `https://cdn.example.com/icon.svg`. * **Server URL**: the base URL of the MCP server. Must start with `https://`, such as `https://app.example.com/mcp`. * **Metadata** (optional): key-value pairs for the connector. Values must be plain strings; nested objects are not supported. For **Auth type**, choose how users authenticate when they connect their account: * **OAuth**: users authorize access through the provider’s OAuth flow, and Scalekit handles the token exchange. * **Bearer token**: users provide a long-lived token issued by the provider. * **API key**: users provide an API key issued by the provider. * **No authentication**: the server is public and requires no credentials. Use this only when the server intentionally allows unauthenticated access and exposes no user-specific data or privileged operations, since every user shares the same anonymous access. 5. Select **Save**. The connector is ready to use when you create a connection. ### Create a connector with the management API [Section titled “Create a connector with the management API”](#create-a-connector-with-the-management-api) Build the connector payload using the reference and examples that follow, then create the connector with the management API. Below are example payloads for API and MCP connectors across all supported auth patterns. Stateless MCP servers only Scalekit connects to **stateless MCP servers** only. Stateful MCP servers that require persistent sticky connections or MCP session IDs are not supported. * API Connector * OAuth ```json 1 { 2 "display_name": "My Asana", 3 "description": "Connect to Asana. Manage tasks, projects, teams, and workflow automation", 4 "auth_patterns": [ 5 { 6 "type": "OAUTH", 7 "display_name": "OAuth 2.0", 8 "description": "Authenticate with Asana using OAuth 2.0 for comprehensive project management", 9 "fields": [], 10 "oauth_config": { 11 "authorize_uri": "https://app.asana.com/-/oauth_authorize", 12 "token_uri": "https://app.asana.com/-/oauth_token", 13 "user_info_uri": "https://app.asana.com/api/1.0/users/me", 14 "available_scopes": [ 15 { 16 "scope": "profile", 17 "display_name": "Profile", 18 "description": "Access user profile information", 19 "required": true 20 }, 21 { 22 "scope": "email", 23 "display_name": "Email", 24 "description": "Access user email address", 25 "required": true 26 } 27 ] 28 } 29 } 30 ], 31 "proxy_url": "https://app.asana.com/api", 32 "proxy_enabled": true 33 } ``` * Bearer ```json 1 { 2 "display_name": "My Bearer Token Provider", 3 "description": "Connect to an API that accepts a static bearer token", 4 "auth_patterns": [ 5 { 6 "type": "BEARER", 7 "display_name": "Bearer Token", 8 "description": "Authenticate with a static bearer token", 9 "fields": [ 10 { 11 "field_name": "token", 12 "label": "Bearer Token", 13 "input_type": "password", 14 "hint": "Your long-lived bearer token", 15 "required": true 16 } 17 ] 18 } 19 ], 20 "proxy_url": "https://api.example.com", 21 "proxy_enabled": true 22 } ``` * Basic ```json 1 { 2 "display_name": "My Freshdesk", 3 "description": "Connect to Freshdesk. Manage tickets, contacts, companies, and customer support workflows", 4 "auth_patterns": [ 5 { 6 "type": "BASIC", 7 "display_name": "Basic Auth", 8 "description": "Authenticate with Freshdesk using Basic Auth with username and password for comprehensive helpdesk management", 9 "fields": [ 10 { 11 "field_name": "domain", 12 "label": "Freshdesk Domain", 13 "input_type": "text", 14 "hint": "Your Freshdesk domain (e.g., yourcompany.freshdesk.com)", 15 "required": true 16 }, 17 { 18 "field_name": "username", 19 "label": "API Key", 20 "input_type": "text", 21 "hint": "Your Freshdesk API Key", 22 "required": true 23 } 24 ] 25 } 26 ], 27 "proxy_url": "https://{{domain}}/api", 28 "proxy_enabled": true 29 } ``` * API Key ```json 1 { 2 "display_name": "My Attention", 3 "description": "Connect to Attention for AI insights, conversations, teams, and workflows", 4 "auth_patterns": [ 5 { 6 "type": "API_KEY", 7 "display_name": "API Key", 8 "description": "Authenticate with Attention using an API Key", 9 "fields": [ 10 { 11 "field_name": "api_key", 12 "label": "Integration Token", 13 "input_type": "password", 14 "hint": "Your Attention API Key", 15 "required": true 16 } 17 ] 18 } 19 ], 20 "proxy_url": "https://api.attention.tech", 21 "proxy_enabled": true 22 } ``` * MCP Connector ```json 1 { 2 "display_name": "My Asana", 3 "description": "Connect to Asana. Manage tasks, projects, teams, and workflow automation", 4 "auth_patterns": [ 5 { 6 "type": "OAUTH", 7 "display_name": "OAuth 2.0", 8 "description": "Authenticate with Asana using OAuth 2.0 for comprehensive project management", 9 "fields": [], 10 "oauth_config": { 11 "authorize_uri": "https://app.asana.com/-/oauth_authorize", 12 "token_uri": "https://app.asana.com/-/oauth_token", 13 "user_info_uri": "https://app.asana.com/api/1.0/users/me", 14 "available_scopes": [ 15 { 16 "scope": "profile", 17 "display_name": "Profile", 18 "description": "Access user profile information", 19 "required": true 20 }, 21 { 22 "scope": "email", 23 "display_name": "Email", 24 "description": "Access user email address", 25 "required": true 26 } 27 ] 28 } 29 } 30 ], 31 "proxy_url": "https://app.asana.com/api", 32 "proxy_enabled": true 33 } ``` * OAuth ```json 1 { 2 "display_name": "My Bearer Token Provider", 3 "description": "Connect to an API that accepts a static bearer token", 4 "auth_patterns": [ 5 { 6 "type": "BEARER", 7 "display_name": "Bearer Token", 8 "description": "Authenticate with a static bearer token", 9 "fields": [ 10 { 11 "field_name": "token", 12 "label": "Bearer Token", 13 "input_type": "password", 14 "hint": "Your long-lived bearer token", 15 "required": true 16 } 17 ] 18 } 19 ], 20 "proxy_url": "https://api.example.com", 21 "proxy_enabled": true 22 } ``` * Bearer ```json 1 { 2 "display_name": "My Freshdesk", 3 "description": "Connect to Freshdesk. Manage tickets, contacts, companies, and customer support workflows", 4 "auth_patterns": [ 5 { 6 "type": "BASIC", 7 "display_name": "Basic Auth", 8 "description": "Authenticate with Freshdesk using Basic Auth with username and password for comprehensive helpdesk management", 9 "fields": [ 10 { 11 "field_name": "domain", 12 "label": "Freshdesk Domain", 13 "input_type": "text", 14 "hint": "Your Freshdesk domain (e.g., yourcompany.freshdesk.com)", 15 "required": true 16 }, 17 { 18 "field_name": "username", 19 "label": "API Key", 20 "input_type": "text", 21 "hint": "Your Freshdesk API Key", 22 "required": true 23 } 24 ] 25 } 26 ], 27 "proxy_url": "https://{{domain}}/api", 28 "proxy_enabled": true 29 } ``` * Basic ```json 1 { 2 "display_name": "My Attention", 3 "description": "Connect to Attention for AI insights, conversations, teams, and workflows", 4 "auth_patterns": [ 5 { 6 "type": "API_KEY", 7 "display_name": "API Key", 8 "description": "Authenticate with Attention using an API Key", 9 "fields": [ 10 { 11 "field_name": "api_key", 12 "label": "Integration Token", 13 "input_type": "password", 14 "hint": "Your Attention API Key", 15 "required": true 16 } 17 ] 18 } 19 ], 20 "proxy_url": "https://api.attention.tech", 21 "proxy_enabled": true 22 } ``` * API Key * OAuth ```json 1 { 2 "display_name": "Github MCP", 3 "description": "Connect to Github MCP", 4 "auth_patterns": [ 5 { 6 "description": "Authenticate with Github MCP using browser OAuth.", 7 "display_name": "OAuth 2.1/DCR", 8 "fields": [], 9 "is_mcp": true, 10 "oauth_config": { 11 "pkce_enabled": true 12 }, 13 "type": "OAUTH" 14 } 15 ], 16 "proxy_url": "https://api.githubcopilot.com/mcp/", 17 "proxy_enabled": true 18 } ``` * Bearer ```json 1 { 2 "display_name": "Apify MCP", 3 "description": "Connect to Apify MCP to run web scraping, browser automation, and data extraction Actors directly from your AI workflows.", 4 "auth_patterns": [ 5 { 6 "description": "Authenticate with Apify using your API Token.", 7 "display_name": "Apify Token", 8 "fields": [ 9 { 10 "field_name": "token", 11 "hint": "Your Apify API Token", 12 "input_type": "password", 13 "label": "Apify Token", 14 "required": true 15 } 16 ], 17 "is_mcp": true, 18 "type": "BEARER" 19 } 20 ], 21 "proxy_url": "https://mcp.apify.com", 22 "proxy_enabled": true 23 } ``` * Basic ```json 1 { 2 "display_name": "My Internal MCP", 3 "description": "Connect to an internal MCP server that authenticates with a username and password", 4 "auth_patterns": [ 5 { 6 "type": "BASIC", 7 "display_name": "Basic Auth", 8 "description": "Authenticate with a username and password", 9 "is_mcp": true, 10 "fields": [ 11 { 12 "field_name": "username", 13 "label": "Username", 14 "input_type": "text", 15 "hint": "Your username", 16 "required": true 17 }, 18 { 19 "field_name": "password", 20 "label": "Password", 21 "input_type": "password", 22 "hint": "Your password", 23 "required": true 24 } 25 ] 26 } 27 ], 28 "proxy_url": "https://mcp.internal.example.com", 29 "proxy_enabled": true 30 } ``` * API Key ```json 1 { 2 "display_name": "My API Key MCP", 3 "description": "Connect to an MCP server that authenticates with a static API key", 4 "auth_patterns": [ 5 { 6 "type": "API_KEY", 7 "display_name": "API Key", 8 "description": "Authenticate with a static API key", 9 "is_mcp": true, 10 "fields": [ 11 { 12 "field_name": "api_key", 13 "label": "API Key", 14 "input_type": "password", 15 "hint": "Your API key", 16 "required": true 17 } 18 ] 19 } 20 ], 21 "proxy_url": "https://mcp.example.com", 22 "proxy_enabled": true 23 } ``` * No Auth ```json 1 { 2 "display_name": "Public Docs MCP", 3 "description": "Connect to a public MCP server that requires no credentials", 4 "auth_patterns": [ 5 { 6 "type": "NO_AUTH", 7 "display_name": "No Auth", 8 "description": "Public server - no credentials required.", 9 "is_mcp": true, 10 "fields": [] 11 } 12 ], 13 "proxy_url": "https://mcp.example.com", 14 "proxy_enabled": true 15 } ``` * OAuth ```json 1 { 2 "display_name": "Github MCP", 3 "description": "Connect to Github MCP", 4 "auth_patterns": [ 5 { 6 "description": "Authenticate with Github MCP using browser OAuth.", 7 "display_name": "OAuth 2.1/DCR", 8 "fields": [], 9 "is_mcp": true, 10 "oauth_config": { 11 "pkce_enabled": true 12 }, 13 "type": "OAUTH" 14 } 15 ], 16 "proxy_url": "https://api.githubcopilot.com/mcp/", 17 "proxy_enabled": true 18 } ``` * Bearer ```json 1 { 2 "display_name": "Apify MCP", 3 "description": "Connect to Apify MCP to run web scraping, browser automation, and data extraction Actors directly from your AI workflows.", 4 "auth_patterns": [ 5 { 6 "description": "Authenticate with Apify using your API Token.", 7 "display_name": "Apify Token", 8 "fields": [ 9 { 10 "field_name": "token", 11 "hint": "Your Apify API Token", 12 "input_type": "password", 13 "label": "Apify Token", 14 "required": true 15 } 16 ], 17 "is_mcp": true, 18 "type": "BEARER" 19 } 20 ], 21 "proxy_url": "https://mcp.apify.com", 22 "proxy_enabled": true 23 } ``` * Basic ```json 1 { 2 "display_name": "My Internal MCP", 3 "description": "Connect to an internal MCP server that authenticates with a username and password", 4 "auth_patterns": [ 5 { 6 "type": "BASIC", 7 "display_name": "Basic Auth", 8 "description": "Authenticate with a username and password", 9 "is_mcp": true, 10 "fields": [ 11 { 12 "field_name": "username", 13 "label": "Username", 14 "input_type": "text", 15 "hint": "Your username", 16 "required": true 17 }, 18 { 19 "field_name": "password", 20 "label": "Password", 21 "input_type": "password", 22 "hint": "Your password", 23 "required": true 24 } 25 ] 26 } 27 ], 28 "proxy_url": "https://mcp.internal.example.com", 29 "proxy_enabled": true 30 } ``` * API Key ```json 1 { 2 "display_name": "My API Key MCP", 3 "description": "Connect to an MCP server that authenticates with a static API key", 4 "auth_patterns": [ 5 { 6 "type": "API_KEY", 7 "display_name": "API Key", 8 "description": "Authenticate with a static API key", 9 "is_mcp": true, 10 "fields": [ 11 { 12 "field_name": "api_key", 13 "label": "API Key", 14 "input_type": "password", 15 "hint": "Your API key", 16 "required": true 17 } 18 ] 19 } 20 ], 21 "proxy_url": "https://mcp.example.com", 22 "proxy_enabled": true 23 } ``` * No Auth ```json 1 { 2 "display_name": "Public Docs MCP", 3 "description": "Connect to a public MCP server that requires no credentials", 4 "auth_patterns": [ 5 { 6 "type": "NO_AUTH", 7 "display_name": "No Auth", 8 "description": "Public server - no credentials required.", 9 "is_mcp": true, 10 "fields": [] 11 } 12 ], 13 "proxy_url": "https://mcp.example.com", 14 "proxy_enabled": true 15 } ``` **Before submitting, review the final payload carefully:** * `display_name` and `description` * The selected auth `type` * Required `fields` and `account_fields` * OAuth endpoints and scopes, if the connector uses OAuth * `proxy_url` * Whether `is_mcp` is set to `true` for MCP providers Use the payload for your auth type as the request body in the create request: * cURL Terminal ```bash 1 # $env_access_token and $SCALEKIT_CLIENT_SECRET are secrets - keep them server-side and out of source control. 2 # --fail-with-body makes curl exit non-zero and print the error body on a non-2xx response. 3 curl --fail-with-body --location "$SCALEKIT_ENVIRONMENT_URL/api/v1/custom-providers" \ 4 --header "Authorization: Bearer $env_access_token" \ 5 --header "Content-Type: application/json" \ 6 --data '{...}' ``` * Python The Python SDK builds the payload with typed request objects and authenticates using your client credentials - no separate access token step is needed. It covers MCP connector auth types: OAuth (via Dynamic Client Registration), Bearer, API key, and No Auth. The example below creates an OAuth MCP connector; swap the `AuthPattern` for the auth type you need. create\_connector.py ```python 1 import scalekit.client, os 2 from dotenv import load_dotenv 3 from scalekit.actions.types import AuthPattern, OAuthConfig, CreateCustomProviderRequest 4 from scalekit.common.exceptions import ScalekitException 5 load_dotenv() 6 7 # Load credentials from the environment. Keep SCALEKIT_CLIENT_SECRET server-side - 8 # never commit it or expose it in client-side code. 9 scalekit_client = scalekit.client.ScalekitClient( 10 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 11 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 12 env_url=os.getenv("SCALEKIT_ENV_URL"), 13 ) 14 15 try: 16 response = scalekit_client.actions.providers.create_custom_provider( 17 CreateCustomProviderRequest( 18 display_name="Github MCP", 19 description="Connect to Github MCP", 20 proxy_url="https://api.githubcopilot.com/mcp/", 21 proxy_enabled=True, 22 auth_patterns=[ 23 AuthPattern( 24 type="OAUTH", 25 display_name="OAuth 2.1/DCR", 26 description="Authenticate with Github MCP using browser OAuth.", 27 is_mcp=True, 28 oauth_config=OAuthConfig(), # pkce_enabled=True by default 29 ) 30 ], 31 # Optional: icon_src="https://cdn.example.com/icon.svg", 32 # Optional: metadata={"team": "platform"}, 33 ) 34 ) 35 print("Created connector:", response.provider.identifier) 36 except ScalekitException as err: 37 # Handle validation errors, conflicts (duplicate name), auth failures, etc. 38 print("Failed to create connector:", err) 39 raise ``` A successful request returns the created connector. Next, create a connection in the Scalekit Dashboard, then continue with the standard connector flow to authorize users and call tools. ## List connectors [Section titled “List connectors”](#list-connectors) List existing connectors before you create one, to confirm whether a connector for the upstream already exists. You also need the list to find a connector’s `identifier` for update and delete requests. * cURL Terminal ```bash 1 # $env_access_token is a secret - keep it server-side and out of source control. 2 curl --fail-with-body --location "$SCALEKIT_ENVIRONMENT_URL/api/v1/providers?filter.provider_type=CUSTOM&page_size=1000" \ 3 --header "Authorization: Bearer $env_access_token" ``` * Python list\_connectors.py ```python 1 import scalekit.client, os 2 from dotenv import load_dotenv 3 from scalekit.actions.types import ListProvidersRequest 4 from scalekit.v1.providers.providers_pb2 import ProviderType 5 from scalekit.common.exceptions import ScalekitException 6 load_dotenv() 7 8 # Keep SCALEKIT_CLIENT_SECRET server-side - never commit it or expose it client-side. 9 scalekit_client = scalekit.client.ScalekitClient( 10 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 11 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 12 env_url=os.getenv("SCALEKIT_ENV_URL"), 13 ) 14 15 try: 16 response = scalekit_client.actions.providers.list_providers( 17 ListProvidersRequest(provider_type=ProviderType.CUSTOM, page_size=1000) 18 ) 19 for provider in response.providers: 20 print(provider.identifier, provider.display_name) 21 except ScalekitException as err: 22 print("Failed to list connectors:", err) 23 raise ``` ## Update a connector [Section titled “Update a connector”](#update-a-connector) Use the [List connectors](#list-connectors) API to get the connector `identifier`, then send the updated payload. Include `display_name`, `proxy_url`, and `auth_patterns` on every update, and echo back any other fields you want to keep - omitted fields are not preserved, so read the current connector first and change only what you need. * cURL Terminal ```bash 1 # $env_access_token and $SCALEKIT_CLIENT_SECRET are secrets - keep them server-side and out of source control. 2 curl --fail-with-body --location --request PUT "$SCALEKIT_ENVIRONMENT_URL/api/v1/custom-providers/$PROVIDER_IDENTIFIER" \ 3 --header "Authorization: Bearer $env_access_token" \ 4 --header "Content-Type: application/json" \ 5 --data '{...}' ``` * Python update\_connector.py ```python 1 import scalekit.client, os 2 from dotenv import load_dotenv 3 from scalekit.actions.types import ListProvidersRequest, UpdateCustomProviderRequest 4 from scalekit.common.exceptions import ScalekitException 5 load_dotenv() 6 7 # Keep SCALEKIT_CLIENT_SECRET server-side - never commit it or expose it client-side. 8 scalekit_client = scalekit.client.ScalekitClient( 9 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 10 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 11 env_url=os.getenv("SCALEKIT_ENV_URL"), 12 ) 13 14 provider_identifier = "prov_..." # from list_providers 15 16 try: 17 # Read the current state, then echo back every field you want to keep. 18 current = scalekit_client.actions.providers.list_providers( 19 ListProvidersRequest(identifier=provider_identifier) 20 ).providers[0] 21 22 response = scalekit_client.actions.providers.update_custom_provider( 23 UpdateCustomProviderRequest( 24 identifier=current.identifier, 25 display_name=current.display_name, 26 proxy_url=current.proxy_url, 27 description="Updated description", 28 auth_patterns=current.auth_patterns, 29 metadata=dict(current.metadata), 30 ) 31 ) 32 print("Updated connector:", response.provider.identifier) 33 except ScalekitException as err: 34 print("Failed to update connector:", err) 35 raise ``` ## Delete a connector [Section titled “Delete a connector”](#delete-a-connector) Use the [List connectors](#list-connectors) API to get the connector `identifier`. If the connector is still in use, remove the related connections or connected accounts first. * cURL Terminal ```bash 1 # $env_access_token is a secret - keep it server-side and out of source control. 2 curl --fail-with-body --location --request DELETE "$SCALEKIT_ENVIRONMENT_URL/api/v1/custom-providers/$PROVIDER_IDENTIFIER" \ 3 --header "Authorization: Bearer $env_access_token" ``` * Python delete\_connector.py ```python 1 import scalekit.client, os 2 from dotenv import load_dotenv 3 from scalekit.actions.types import DeleteCustomProviderRequest 4 from scalekit.common.exceptions import ScalekitException 5 load_dotenv() 6 7 # Keep SCALEKIT_CLIENT_SECRET server-side - never commit it or expose it client-side. 8 scalekit_client = scalekit.client.ScalekitClient( 9 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 10 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 11 env_url=os.getenv("SCALEKIT_ENV_URL"), 12 ) 13 14 try: 15 scalekit_client.actions.providers.delete_custom_provider( 16 DeleteCustomProviderRequest(identifier="prov_...") 17 ) 18 print("Connector deleted.") 19 except ScalekitException as err: 20 # e.g. not found, or forbidden if the connector is still in use. 21 print("Failed to delete connector:", err) 22 raise ``` ## Next steps [Section titled “Next steps”](#next-steps) With the connector created and a connection in place, authorize a user and start calling the upstream: * [Making tool calls](/agentkit/bring-your-own-connector/making-tool-calls) - call the upstream API or MCP server through your connector. --- # DOCUMENT BOUNDARY --- # Making tool calls > Make tool calls using a REST API connector via Tool Proxy, or discover and execute tools from a custom MCP connector. Use this page to make tool calls after the connector, connection, and connected account are set up. The call method depends on the connector type: * **REST API connectors** — use `actions.request()` to proxy HTTP calls through Tool Proxy * **MCP connectors** — use `list_scoped_tools` to discover available tools, then `execute_tool` to call them Both types use the same connection, connected account, and user authorization model. ## Prerequisites [Section titled “Prerequisites”](#prerequisites) Make sure: * The connector exists and is configured with the right [auth pattern](/agentkit/bring-your-own-connector/create-connector) * A [connection](/agentkit/connections) is configured for the connector * The [connected account](/agentkit/connected-accounts) exists * The user has completed [authorization](/agentkit/tools/authorize) Create a connection for your connector in the Scalekit Dashboard: ![Connections page showing a custom connector connection alongside built-in connectors](/.netlify/images?url=_astro%2Fcustom-provider-connection.CmpN35cw.png\&w=2604\&h=762\&dpl=6a7afd35ca95e20008d421ee) After the user completes authorization, the connected account appears in the Connected Accounts tab: ![Connected Accounts tab showing an authenticated account for a custom connector](/.netlify/images?url=_astro%2Fcustom-provider-connected-account.CNBQ7XLh.png\&w=2610\&h=624\&dpl=6a7afd35ca95e20008d421ee) ## REST API proxy calls [Section titled “REST API proxy calls”](#rest-api-proxy-calls) In the request examples below, `path` is relative to the connector `proxy_url`. `connectionName` must match the connection you created, and `identifier` must match the connected account you want to use for the request. * Node.js ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node'; 2 import 'dotenv/config'; 3 4 const connectionName = 'your-provider-connection'; // get your connection name from connection configurations 5 const identifier = 'user_123'; // your unique user identifier 6 7 // Get your credentials from app.scalekit.com → Developers → Settings → API Credentials 8 const scalekit = new ScalekitClient( 9 process.env.SCALEKIT_ENV_URL, 10 process.env.SCALEKIT_CLIENT_ID, 11 process.env.SCALEKIT_CLIENT_SECRET 12 ); 13 const actions = scalekit.actions; 14 15 // Authenticate the user 16 const { link } = await actions.getAuthorizationLink({ 17 connectionName, 18 identifier, 19 }); 20 console.log('Authorize connector:', link); 21 process.stdout.write('Press Enter after authorizing...'); 22 await new Promise(r => process.stdin.once('data', r)); 23 24 // Make a request via Scalekit proxy 25 const result = await actions.request({ 26 connectionName, 27 identifier, 28 path: '/v1/customers', 29 method: 'GET', 30 }); 31 console.log(result); ``` * Python ```python 1 import scalekit.client, os 2 from dotenv import load_dotenv 3 load_dotenv() 4 5 connection_name = "your-provider-connection" # get your connection name from connection configurations 6 identifier = "user_123" # your unique user identifier 7 8 # Get your credentials from app.scalekit.com → Developers → Settings → API Credentials 9 scalekit_client = scalekit.client.ScalekitClient( 10 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 11 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 12 env_url=os.getenv("SCALEKIT_ENV_URL"), 13 ) 14 actions = scalekit_client.actions 15 16 # Authenticate the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier 20 ) 21 # present this link to your user for authorization, or click it yourself for testing 22 print("Authorize connector:", link_response.link) 23 input("Press Enter after authorizing...") 24 25 # Make a request via Scalekit proxy 26 result = actions.request( 27 connection_name=connection_name, 28 identifier=identifier, 29 path="/v1/customers", 30 method="GET" 31 ) 32 print(result) ``` The request shape stays the same regardless of auth type — the connector definition controls how Scalekit authenticates the call. ## MCP tool calling [Section titled “MCP tool calling”](#mcp-tool-calling) MCP connectors expose tools from the upstream MCP server. Discover the available tools, then execute them by name. Call `execute_tool` with the connection name, identifier, and any tool-specific input. Tool output lives in `response.data` — see [Understand tool response shape](/agentkit/tools/scalekit-optimized-tools/#understand-tool-response-shape) before parsing results. * Node.js ```typescript 1 const actions = scalekit.actions; 2 3 const result = await actions.executeTool({ 4 toolName: 'tool_name_from_discovery', // replace with a name from list_scoped_tools 5 connector: 'your-mcp-connection', 6 identifier: 'user_123', 7 toolInput: { key: 'value' }, // replace with the tool's required input 8 }); 9 console.log(result.data); ``` * Python ```python 1 actions = scalekit_client.actions 2 3 result = actions.execute_tool( 4 tool_name="tool_name_from_discovery", # replace with a name from list_scoped_tools 5 connection_name="your-mcp-connection", 6 identifier="user_123", 7 tool_input={"key": "value"}, # replace with the tool's required input 8 ) 9 print(result.data) ``` --- # DOCUMENT BOUNDARY --- # AgentKit code samples > Code samples of AI agents using Scalekit along with LangChain, Google ADK, and direct integrations ### [Connect LangChain agents to Gmail](https://github.com/scalekit-inc/sample-langchain-agent) [Securely connect a LangChain agent to Gmail using Scalekit for authentication. Python example for tool authorization.](https://github.com/scalekit-inc/sample-langchain-agent) ### [Connect Google GenAI agents to Gmail](https://github.com/scalekit-inc/google-adk-agent-example) [Build a Google ADK agent that securely accesses Gmail tools. Python example demonstrating Scalekit auth integration.](https://github.com/scalekit-inc/google-adk-agent-example) ### [Connect agents to Slack tools](https://github.com/scalekit-inc/python-connect-demos/tree/main/direct) [Authorize Python agents to use Slack tools with Scalekit. Direct integration example for secure tool access.](https://github.com/scalekit-inc/python-connect-demos/tree/main/direct) ### [Browse all agent auth examples](https://github.com/scalekit-developers/agent-auth-examples) [A curated collection of working examples showing how to build agents that authenticate and access tools using Scalekit.](https://github.com/scalekit-developers/agent-auth-examples) --- # DOCUMENT BOUNDARY --- # Manage connected accounts > Check status, list, delete, and update credentials for connected accounts across all connector auth types. A **connected account** is the per-user record that holds a user’s credentials and tracks their authorization state for a specific connection. Scalekit creates one automatically when a user completes authentication. ## Account states [Section titled “Account states”](#account-states) | State | Meaning | | ---------------------- | --------------------------------------------------------------------------- | | `ACTIVE` | Credentials valid, ready for tool calls | | `EXPIRED` | Access token expired and needs refresh or re-authentication | | `PENDING_AUTH` | User hasn’t completed authentication, or re-authentication is in progress | | `PENDING_VERIFICATION` | OAuth complete; user identity verification still required before activation | | `DISCONNECTED` | Account was manually disconnected | See [Troubleshoot connection errors](/agentkit/authentication/troubleshooting/#connected-account-status) for what to do in each state. ## Check account status [Section titled “Check account status”](#check-account-status) Use `get_or_create_connected_account` as the safe default when a user may be connecting for the first time. Use `get_connected_account` only when you know the account already exists and you need to inspect or return its stored auth details. * Python ```python 1 response = actions.get_or_create_connected_account( 2 connection_name="github-connect", 3 identifier="user_123" 4 ) 5 connected_account = response.connected_account 6 print(f"Status: {connected_account.status}") ``` * Node.js ```typescript 1 const response = await actions.getOrCreateConnectedAccount({ 2 connectionName: 'github-connect', 3 identifier: 'user_123', 4 }); 5 6 console.log('Status:', response.connectedAccount?.status); ``` ## Handle inactive accounts [Section titled “Handle inactive accounts”](#handle-inactive-accounts) When a connected account isn’t `ACTIVE`, generate a new authorization link and send it to the user. The link opens a **Hosted Page**, a Scalekit-hosted UI that adapts automatically based on the connection’s auth type: * **OAuth connectors**: presents the provider’s OAuth consent screen * **API key, basic auth, or other connectors**: presents a form to collect the required credentials Your code is the same regardless of connector type. Scalekit determines the right flow based on the connection configuration. * Python ```python 1 if connected_account.status != "ACTIVE": 2 link_response = actions.get_authorization_link( 3 connection_name="github-connect", 4 identifier="user_123" 5 ) 6 # Redirect or send link_response.link to the user ``` * Node.js ```typescript 1 import { ConnectorStatus } from '@scalekit-sdk/node/lib/pkg/grpc/scalekit/v1/connected_accounts/connected_accounts_pb'; 2 3 if (connectedAccount?.status !== ConnectorStatus.ACTIVE) { 4 const linkResponse = await actions.getAuthorizationLink({ 5 connectionName: 'github-connect', 6 identifier: 'user_123', 7 }); 8 // Redirect or send linkResponse.link to the user 9 } ``` ## Detect when re-authentication is needed [Section titled “Detect when re-authentication is needed”](#detect-when-re-authentication-is-needed) A connected account can leave the `ACTIVE` state on its own, with no action from you or the user. When that happens, the next tool call fails until the user re-authorizes. To catch it early, subscribe to the `connected_account.status_updated` webhook instead of waiting for a failed call. ### Common causes [Section titled “Common causes”](#common-causes) OAuth connected accounts most often move to `EXPIRED` for reasons outside Scalekit’s control: * **The provider revoked the refresh token.** A password change, an admin-initiated token revocation, or a provider security policy invalidates the refresh token, so Scalekit can no longer obtain new access tokens. * **The refresh token expired.** Providers cap refresh-token lifetimes (for example, 30 or 180 days), and the expiry is rarely surfaced in advance. * **No refresh token was issued.** When the connection’s scopes don’t request offline access, the provider returns only a short-lived access token and no refresh token to renew it. * **The provider hit a per-user token limit.** Some providers keep only a fixed number of refresh tokens per user and app, and silently drop the oldest ones when a user reconnects repeatedly. The first two cases require the user to re-authenticate; there is no server-side workaround. The last two are configuration issues you fix on the connection by requesting offline access scopes. ### Subscribe to status changes [Section titled “Subscribe to status changes”](#subscribe-to-status-changes) The `connected_account.status_updated` event fires on every status transition and carries both the new and previous status: connected\_account.status\_updated ```json 1 { 2 "spec_version": "1", 3 "id": "evt_101652975398683158", 4 "type": "connected_account.status_updated", 5 "occurred_at": "2025-12-02T06:31:34.895815554Z", 6 "environment_id": "env_88640229614813449", 7 "object": "ConnectedAccount", 8 "data": { 9 "id": "ca_133400349586228019", 10 "identifier": "john@acmecorp.com", 11 "connection_id": "conn_133400101014995480", 12 "connection_name": "github-connect", 13 "provider": "GITHUB", 14 "authorization_type": "OAUTH", 15 "status": "EXPIRED", 16 "old_status": "ACTIVE" 17 } 18 } ``` Because the event covers every transition, filter on the change you care about. To alert users only when an active account needs re-authorization, act on `old_status` `ACTIVE` moving to `status` `EXPIRED`: ```js 1 // The event fires for all transitions (for example, PENDING_AUTH to ACTIVE). 2 // Filter to the one that requires user action, or you will notify on noise. 3 if (event.data.old_status === 'ACTIVE' && event.data.status === 'EXPIRED') { 4 // Generate a fresh authorization link and notify the user 5 } ``` When you receive this event, [generate a new authorization link](#handle-inactive-accounts) and prompt the user to reconnect. See the full payload for the [`connected_account.status_updated` event](/apis/#webhook/connectedaccountstatusupdated) in the API reference. ## List connected accounts [Section titled “List connected accounts”](#list-connected-accounts) ```typescript 1 const listResponse = await actions.listConnectedAccounts({ 2 connectionName: 'github-connect', 3 }); 4 console.log('Connected accounts:', listResponse); ``` ## Delete a connected account [Section titled “Delete a connected account”](#delete-a-connected-account) Deleting a connected account removes the user’s credentials and authorization state. The user must re-authenticate to reconnect. ```typescript 1 await actions.deleteConnectedAccount({ 2 connectionName: 'github-connect', 3 identifier: 'user_123', 4 }); ``` ## Update OAuth scopes [Section titled “Update OAuth scopes”](#update-oauth-scopes) Scopes apply to OAuth connectors only. For non-OAuth connectors (API key, basic auth, and similar), generate a new authorization link and the hosted page will collect updated credentials. To request additional OAuth scopes from an existing connected account: 1. Update the connection’s scopes in **AgentKit** > **Connections** > **Edit**. 2. Generate a new authorization link for the user. 3. The user completes the OAuth consent screen, approving the updated scopes. 4. Scalekit updates the connected account with the new token set. --- # DOCUMENT BOUNDARY --- # Configure a connection > Set up a connection in the Scalekit Dashboard to authorize your agent to use a third-party connector on behalf of your users. A **connection** is a configuration you create once in the Scalekit Dashboard. It holds everything Scalekit needs to interact with a connector’s API: OAuth app credentials, scopes, redirect URIs, and so on. One connection serves all your users. Users don’t configure connections. When a user authenticates, Scalekit creates a **connected account**, the per-user record that links their identity to a connection and holds their tokens. ## What the connection form asks for [Section titled “What the connection form asks for”](#what-the-connection-form-asks-for) The connection form adapts to what the connector requires. Two things determine how much you need to configure: * **OAuth-based connectors** require the most setup. You register an OAuth app with the provider, then enter those credentials into Scalekit. * **Non-OAuth connectors** (API key, basic auth, key pairs, and similar) require minimal developer setup (usually just a name). The user provides their own credentials when they create their connected account. The sections below walk through both patterns. ## Set up an OAuth connection [Section titled “Set up an OAuth connection”](#set-up-an-oauth-connection) OAuth connections require you to create an OAuth app with the provider and link it to Scalekit. Scalekit provides the Redirect URI; you bring the Client ID and Client Secret. 1. ### Open the connection form [Section titled “Open the connection form”](#open-the-connection-form) In the Scalekit Dashboard, go to **AgentKit** > **Connections** and click **Add connection**. Select the connector you want to configure. The form shows the fields that connector requires. 2. ### Copy the redirect URI [Section titled “Copy the redirect URI”](#copy-the-redirect-uri) Scalekit generates a **Redirect URI** for this connection. Copy it; you’ll need it in the next step. This URI is where the provider sends the user after they complete the OAuth consent screen. Scalekit handles the callback automatically. 3. ### Register your OAuth app with the provider [Section titled “Register your OAuth app with the provider”](#register-your-oauth-app-with-the-provider) In the provider’s developer console (GitHub, Salesforce, Google, etc.), create an OAuth app and add Scalekit’s Redirect URI to the list of authorized redirect URIs. The provider will give you a **Client ID** and **Client Secret** after registration. Redirect URI must match exactly The URI in the provider’s console must match what Scalekit shows character-for-character, including trailing slashes. A mismatch causes the OAuth flow to fail with a redirect\_uri\_mismatch error. 4. ### Enter your credentials [Section titled “Enter your credentials”](#enter-your-credentials) Back in the Scalekit Dashboard, enter the **Client ID** and **Client Secret** from the provider. 5. ### Configure scopes [Section titled “Configure scopes”](#configure-scopes) Select the scopes your agent needs. Scopes define what your agent can do on the user’s behalf: for example, `read:email` or `repo`. 6. ### Save the connection [Section titled “Save the connection”](#save-the-connection) Click **Save**. The connection is now active and ready for connected accounts to be created against it. ## Set up a non-OAuth connection [Section titled “Set up a non-OAuth connection”](#set-up-a-non-oauth-connection) For connectors that use API keys, basic auth, key pairs, or similar, the connection form asks for very little. In many cases, you only need to give the connection a name. The user provides their own credentials (their API key, account details, or private key) when they create a connected account. Scalekit collects those credentials through the connected account form and stores them securely. 1. Go to **AgentKit** > **Connections** and click **Add connection** 2. Select the connector 3. Enter a **Connection name**: this identifies the connection in the dashboard and in your code 4. Click **Save** When a connected account is created for this connection, Scalekit presents the user with a form that collects the credentials their specific account requires. ## Create multiple connections for the same connector [Section titled “Create multiple connections for the same connector”](#create-multiple-connections-for-the-same-connector) You can create more than one connection for the same connector. This is useful when: * Different groups of users need different scopes * You want to maintain separate OAuth apps for staging and production * You’re integrating with multiple instances of the same service (for example, two different Salesforce orgs) Each connection has its own name, which you use to identify it in API calls and in the dashboard. ## Common scenarios [Section titled “Common scenarios”](#common-scenarios) --- # DOCUMENT BOUNDARY --- # Manage encryption keys > Protect data at rest with Scalekit managed keys or bring your own from a cloud Key Management Service (KMS). Scalekit automatically protects data at rest with encryption keys. You can use Scalekit-managed keys or bring your own from a cloud Key Management Service (KMS) provider if your compliance policy requires you to own and control the root key. This guide shows you how to view and manage keys in the dashboard and set up Bring Your Own Key (BYOK) with GCP Cloud KMS. ## Key types | Type | Description | | ---------------------------------------------- | -------------------------------------------------------------------------------------------------- | | **Scalekit managed Data Encryption Key (DEK)** | Scalekit generates and manages the key. No setup required. | | **Bring your own key (BYOK)** | You provide a key from your own KMS. You own the key lifecycle, including rotation and revocation. | ## Key states | State | Description | | ---------- | ----------------------------------------------------------------------------------------------- | | Staged | Created, not yet in use. No data is encrypted with it. | | Primary | The active key. All new encryption operations use it. | | Deprecated | Replaced by a newer key. Existing records may still reference it until re-encryption completes. | ## Manage keys Go to **Settings** and open the **Encryption keys** tab. 1. **Create a key** Click **Create New Key** and select a provider: * **Scalekit Managed DEK**: Scalekit generates and manages the key. Click **Create**. * **BYOK - GCP Cloud KMS**: Complete [Set up BYOK with GCP KMS](#set-up-byok-with-gcp-kms) first to create the GCP key and grant access, then enter the key resource name here and click **Create**. The key is created in **Staged** state. 2. **Activate the key** Click **Activate** on a Staged key. The key becomes Primary and Scalekit uses it for all new encryption operations. 3. **Re-encrypt existing data** To apply the new key to existing records, click **Re-encrypt Data**. Scalekit decrypts each existing record with the previous key and re-encrypts it with the new key. ## Set up BYOK with GCP KMS Use BYOK to register an encryption key from Google Cloud KMS that your team owns and controls. Scalekit uses the KMS API for all encrypt and decrypt operations and never stores the key material. You own the key lifecycle BYOK gives you direct control over your encryption key. Scalekit cannot rotate or manage the GCP key on your behalf. If the key is disabled, destroyed, or Identity and Access Management (IAM) access is revoked, Scalekit cannot encrypt new data or decrypt existing records until you restore access. ### Prerequisites * A **Google Cloud project** with the [Cloud KMS API enabled](https://cloud.google.com/kms/docs/create-encryption-keys) * **IAM permissions** to create key rings, keys, and set key-level IAM policies * The **Scalekit service account email**, shown in the Scalekit dashboard when you select BYOK * `gcloud` CLI installed and authenticated, or access to the [GCP Console](https://console.cloud.google.com/security/kms) 1. **Create a key ring** A [key ring](https://cloud.google.com/kms/docs/resource-hierarchy#key_rings) groups encryption keys by location. Key rings cannot be deleted or renamed once created. Choose the name and location carefully. * gcloud CLI ```bash 1 gcloud kms keyrings create "scalekit-kms-keyring" \ 2 --location "global" \ 3 --project "YOUR-GCP-PROJECT" ``` Replace `YOUR-GCP-PROJECT` with your Google Cloud project ID. * GCP Console 1. Open [**Security > Key management**](https://console.cloud.google.com/security/kms), click **Key rings**. 2. Click **Create key ring**, enter `scalekit-kms-keyring` as the name. 3. Set **Location** to **Global** and click **Create**. 2. **Create an encryption key** Create a symmetric AES-256-GCM key inside the key ring. * gcloud CLI ```bash 1 gcloud kms keys create "scalekit-kms-key" \ 2 --location "global" \ 3 --keyring "scalekit-kms-keyring" \ 4 --purpose "encryption" \ 5 --project "YOUR-GCP-PROJECT" ``` * GCP Console 1. Click the key ring you created, then click **Create key**. 2. Enter `scalekit-kms-key` as the name. 3. Set **Protection level** to **HSM** (recommended) and click **Continue**. 4. Set **Key material** to **HSM-generated** and click **Continue**. 5. Set **Purpose** to **Symmetric encrypt/decrypt** and click **Continue**. 6. Set **Rotation period** per your policy and click **Create**. 3. **Grant Scalekit access to the key** Grant both roles at the key level to limit Scalekit’s IAM access to this specific key. | Role | Purpose | | -------------------------------------------- | ----------------------------------------------- | | `roles/cloudkms.cryptoKeyEncrypterDecrypter` | Encrypt and decrypt the DEK | | `roles/cloudkms.viewer` | Read key metadata for health checks and listing | * gcloud CLI ```bash 1 gcloud kms keys add-iam-policy-binding "scalekit-kms-key" \ 2 --keyring "scalekit-kms-keyring" \ 3 --location "global" \ 4 --project "YOUR-GCP-PROJECT" \ 5 --member "serviceAccount:SCALEKIT-SERVICE-ACCOUNT" \ 6 --role "roles/cloudkms.cryptoKeyEncrypterDecrypter" 7 8 gcloud kms keys add-iam-policy-binding "scalekit-kms-key" \ 9 --keyring "scalekit-kms-keyring" \ 10 --location "global" \ 11 --project "YOUR-GCP-PROJECT" \ 12 --member "serviceAccount:SCALEKIT-SERVICE-ACCOUNT" \ 13 --role "roles/cloudkms.viewer" ``` * GCP Console 1. In the GCP Console, open **Security > Key management**, click **Key rings**, then click the key ring name. 2. Click the key name, then open the **Permissions** tab. 3. Click **Grant access**. A side panel opens. 4. In the **New principals** field, enter the Scalekit service account email. Copy it from **Settings > Encryption keys > Create New Key > BYOK - GCP Cloud KMS** in the Scalekit dashboard. 5. In the **Assign Roles** section, select **Cloud KMS CryptoKey Encrypter/Decrypter** from the first **Role** dropdown. 6. Click **+ Add another role** and select **Cloud KMS Viewer**. 7. Click **Save**. The policy update takes effect within a few minutes. 4. **Register the key in Scalekit** * In the Scalekit dashboard, go to **Settings** and open the **Encryption keys** tab. * Click **Create New Key** and select **BYOK - GCP Cloud KMS**. * Copy the Scalekit service account email shown in the modal. You need it for step 3 (grant Scalekit access to the key) if you have not granted IAM access yet. * Enter the fully-qualified GCP key resource name: ```plaintext 1 projects/YOUR-GCP-PROJECT/locations/global/keyRings/scalekit-kms-keyring/cryptoKeys/scalekit-kms-key ``` To retrieve the exact name from the CLI: ```bash 1 gcloud kms keys describe "scalekit-kms-key" \ 2 --keyring "scalekit-kms-keyring" \ 3 --location "global" \ 4 --project "YOUR-GCP-PROJECT" \ 5 --format="value(name)" ``` * Click **Create**. The key is created in **Staged** state. 5. **Activate the key** Click **Activate** on the staged key. The key becomes Primary and Scalekit uses it for all new encryption operations. Activation is permanent Once activated, you cannot deactivate the key without creating and activating a new key. Confirm your IAM grants are in place before activating. 6. **Re-encrypt existing data** Activation covers new writes automatically. Click **Re-encrypt Data** to migrate existing records. Scalekit decrypts each record with the previous key and re-encrypts it with the new key. ## Monitor with audit logs Cloud KMS logs every cryptographic operation to [Cloud Audit Logs](https://cloud.google.com/kms/docs/audit-logging). Use this filter in **Cloud Logging** to see all encrypt, decrypt, and key events for your key: ```plaintext 1 resource.type="cloudkms_cryptokey" ``` ## Fix common errors --- # DOCUMENT BOUNDARY --- # Set up and connect a Virtual MCP server > Create a Virtual MCP Server, verify user connections, mint session tokens, and connect your agent using bearer auth. ## Prerequisites [Section titled “Prerequisites”](#prerequisites) Before creating a Virtual MCP Server, configure the connections you want to expose. Each `connection_name` you reference must already exist in **AgentKit > Connections**. See [Configure a connection](/agentkit/connections/) if you haven’t done this yet. ## Create a Virtual MCP server [Section titled “Create a Virtual MCP server”](#create-a-virtual-mcp-server) Create the server once per agent role — not once per user. The response includes a static `mcp_server_url` you reuse for every user and every session. ```python 1 import os 2 from scalekit import ScalekitClient 3 from scalekit.actions.models.mcp_config import McpConfigConnectionToolMapping 4 5 scalekit_client = ScalekitClient( 6 env_url=os.environ["SCALEKIT_ENV_URL"], 7 client_id=os.environ["SCALEKIT_CLIENT_ID"], 8 client_secret=os.environ["SCALEKIT_CLIENT_SECRET"], 9 ) 10 11 vmcp_response = scalekit_client.actions.mcp.create_config( 12 name="email-calendar-agent", 13 connection_tool_mappings=[ 14 McpConfigConnectionToolMapping( 15 connection_name="gmail", 16 tools=["gmail_fetch_mails"], 17 ), 18 McpConfigConnectionToolMapping( 19 connection_name="googlecalendar", 20 tools=[ 21 "googlecalendar_list_events", 22 "googlecalendar_create_event", 23 ], 24 ), 25 ], 26 ) 27 28 config_id = vmcp_response.config.id 29 mcp_server_url = vmcp_response.config.mcp_server_url ``` Save `config_id` and `mcp_server_url`. You pass these to every agent session. **Selecting tools**: Each `McpConfigConnectionToolMapping` controls which tools from a connection appear on the server. Omit `tools` to expose all tools for that connection. To find available tool names, browse **AgentKit > Catalog** or open the connection from **AgentKit > Connections**. ## Connect an agent [Section titled “Connect an agent”](#connect-an-agent) Run these steps before each agent session. 1. ## Check that connections are active [Section titled “Check that connections are active”](#check-that-connections-are-active) Verify all connections are still active for this user before minting a token. OAuth credentials can expire or be revoked at any time. ```python 1 accounts_response = scalekit_client.actions.mcp.list_mcp_connected_accounts( 2 config_id=config_id, 3 identifier="user_123", # your app's unique identifier for this user 4 include_auth_link=True, # include re-auth URLs for any inactive connections 5 ) 6 7 for account in accounts_response.connected_accounts: 8 if account.connected_account_status != "ACTIVE": 9 print(f"{account.connection_name} needs auth: {account.authentication_link}") ``` `identifier` is any string that uniquely identifies a user in your system — an email, user ID, or UUID. Use the same value consistently across all calls. If any connection is not `"ACTIVE"`, surface the `authentication_link` to the user before proceeding. See [Authorize user connections](/agentkit/tools/authorize/). 2. ## Mint a session token [Section titled “Mint a session token”](#mint-a-session-token) Mint a fresh token before every agent run. Never reuse a token from a previous session. ```python 1 from datetime import timedelta 2 3 token_response = scalekit_client.actions.mcp.create_session_token( 4 mcp_config_id=config_id, 5 identifier="user_123", 6 expiry=timedelta(hours=1), 7 ) 8 9 token = token_response.token ``` Set `expiry` longer than the expected agent run duration. For a task that typically takes 20 minutes, a 30-minute expiry is sufficient. 3. ## Pass the token to your agent [Section titled “Pass the token to your agent”](#pass-the-token-to-your-agent) Pass `mcp_server_url` and the session token to your agent framework using bearer auth. ```python 1 mcp_server = { 2 "url": mcp_server_url, 3 "headers": {"Authorization": f"Bearer {token}"}, 4 } ``` How you register the MCP server depends on your framework. For a complete end-to-end example using Claude Managed Agents — including vault-based auth injection and response streaming — see [Claude Managed Agents](/agentkit/examples/claude-managed-agents/). ## Manage servers [Section titled “Manage servers”](#manage-servers) **List servers** ```python 1 configs = scalekit_client.actions.mcp.list_configs() 2 for config in configs.configs: 3 print(config.id, config.name, config.mcp_server_url) 4 5 # Filter by name 6 configs = scalekit_client.actions.mcp.list_configs(filter_name="email-calendar-agent") ``` **Update a server** You can update `description` or `connection_tool_mappings` on an existing server. Only do this when no agent sessions are actively running — updating mid-session can cause tools to become unavailable. For significant changes, create a new server and swap the `mcp_server_url` in your agent definition so existing sessions complete cleanly. ```python 1 scalekit_client.actions.mcp.update_config( 2 config_id=config_id, 3 connection_tool_mappings=[ 4 McpConfigConnectionToolMapping( 5 connection_name="gmail", 6 tools=["gmail_fetch_mails", "gmail_send_mail"], 7 ), 8 McpConfigConnectionToolMapping( 9 connection_name="googlecalendar", 10 tools=["googlecalendar_create_event", "googlecalendar_list_events"], 11 ), 12 ], 13 ) ``` **Delete a server** ```python 1 scalekit_client.actions.mcp.delete_config(config_id=config_id) ``` Deleting a server immediately invalidates the `mcp_server_url`. Any agent connected to that URL loses tool access. Confirm no active sessions are running before deleting. --- # DOCUMENT BOUNDARY --- # OpenClaw skill > Connect OpenClaw agents to third-party services through Scalekit. Supports LinkedIn, Notion, Slack, Gmail, and 200+ connectors. Use the Scalekit AgentKit skill for [OpenClaw](https://github.com/scalekit-inc/openclaw-skill) to let your AI agents execute actions on third-party services directly from conversations. Search LinkedIn, read Notion pages, send Slack messages, query Snowflake, and more, all through Scalekit Connect without storing tokens or API keys in your agent. Security considerations for AI agents Scalekit stores tokens and API keys securely with full audit logging. OpenClaw, like all AI agent frameworks, is vulnerable to prompt injection and other agent-level attacks. Follow security best practices to protect your instance. When you ask Claude to interact with a third-party service, the skill: * Finds the configured connector in Scalekit (e.g., [Gmail connection setup](/agentkit/connectors/gmail/)) and identifies which connection to use based on the requested action * Checks if the connection is active. For OAuth connections, it generates a magic link for new authorizations. For API key connections, it provides Dashboard guidance for setup * Retrieves available tools and their parameter schemas for the connector, determining what actions are possible * Calls the right tool with the correct parameters and returns the result to your conversation * If no tool exists for the action, routes the request through Scalekit’s HTTP proxy, making direct API calls on your behalf Your agent never stores tokens or API keys. Scalekit acts as a token vault, managing all OAuth tokens, API keys, and credentials. The skill retrieves only what it needs at runtime, scoped to the requesting user. ## Prerequisites [Section titled “Prerequisites”](#prerequisites) * [OpenClaw](https://openclaw.ai) installed and configured * A Scalekit account with AgentKit enabled: [sign up at app.scalekit.com](https://app.scalekit.com) * `python3` and `uv` available in your PATH ## Get started [Section titled “Get started”](#get-started) 1. ## Install the skill [Section titled “Install the skill”](#install-the-skill) Install the skill from ClawHub: ```bash clawhub install scalekit-agent-auth ``` 2. ## Configure credentials [Section titled “Configure credentials”](#configure-credentials) Add your Scalekit credentials to `.env` in your project root: .env ```bash 1 TOOL_CLIENT_ID=skc_your_client_id # Your Scalekit client ID 2 TOOL_CLIENT_SECRET=your_client_secret # Your Scalekit client secret 3 TOOL_ENV_URL=https://your-env.scalekit.cloud # Your Scalekit environment URL 4 TOOL_IDENTIFIER=your_default_user_identifier # Default user context for tool calls ``` | Parameter | Description | | -------------------- | --------------------------------------------------- | | `TOOL_CLIENT_ID` | Your Scalekit client ID Required | | `TOOL_CLIENT_SECRET` | Your Scalekit client secret Required | | `TOOL_ENV_URL` | Your Scalekit environment URL Required | | `TOOL_IDENTIFIER` | Default user context for all tool calls Recommended | Environment variable security Never commit `.env` files to version control. Add `.env` to your `.gitignore` file to prevent accidental exposure of credentials. 3. ## Usage [Section titled “Usage”](#usage) * Gmail ```txt You: Show me my latest unread emails ``` OpenClaw will automatically: 1. Look up the `GMAIL` connection 2. Verify it’s active (or generate a magic link to authorize if needed) 3. Fetch the `gmail_list_emails` tool schema 4. Return your latest unread emails * Notion ```txt You: Read my Notion page https://notion.so/My-Page-abc123 ``` OpenClaw will: 1. Look up the `NOTION` connection 2. If not yet authorized, generate a magic link for you to complete OAuth 3. Fetch the `notion_page_get` tool schema 4. Return the page content ## Supported connectors [Section titled “Supported connectors”](#supported-connectors) Any connector configured in Scalekit works with the OpenClaw skill, including Notion, Slack, Gmail, Google Sheets, GitHub, Salesforce, HubSpot, Linear, Snowflake, Exa, HarvestAPI, and 200+ more. [Browse connections](/agentkit/connectors/)See all supported connectors in the Scalekit dashboard [ClawHub listing](https://clawhub.dev/skills/scalekit-agent-auth)Install scalekit-agent-auth from ClawHub ## Common scenarios [Section titled “Common scenarios”](#common-scenarios) --- # DOCUMENT BOUNDARY --- # Node.js SDK > Install and initialize the Scalekit Node.js SDK for AgentKit. Install the Node.js SDK, create a `ScalekitClient`, then use the sidebar clients for AgentKit. * **Connected accounts** (`scalekit.actions`) — connect end-user accounts and execute tools * **Tool calling** (`scalekit.tools`) — raw tool definitions for custom adapters * **Error handling** — typed exceptions for API failures ## Install [Section titled “Install”](#install) ```bash 1 npm install @scalekit-sdk/node ``` ## Initialize [Section titled “Initialize”](#initialize) ```ts import { ScalekitClient } from '@scalekit-sdk/node' // Security: load credentials from environment variables — never hard-code secrets const scalekit = new ScalekitClient( process.env.SCALEKIT_ENVIRONMENT_URL!, process.env.SCALEKIT_CLIENT_ID!, process.env.SCALEKIT_CLIENT_SECRET! ) ``` ## Next steps [Section titled “Next steps”](#next-steps) 1. [Connected accounts](/agentkit/sdks/node/actions/) — authorization links, connected accounts, `executeTool` 2. [Tool calling](/agentkit/sdks/node/tools/) — list tools for custom adapters 3. [Error handling](/agentkit/sdks/node/errors/) — catch `ScalekitNotFoundException` and related types --- # DOCUMENT BOUNDARY --- # Connected accounts > Connect accounts, start auth, and execute tools with scalekit.actions `scalekit.actions` is the primary AgentKit client for connecting end-user accounts, starting OAuth, and executing tools on their behalf. **Common path:** create or look up a connected account → get an authorization link → verify the user after redirect → run tools with `executeTool`. For raw tool schemas used by custom adapters, see [Tool calling](/agentkit/sdks/node/tools/). For exception types, see [Error handling](/agentkit/sdks/node/errors/). ### verifyConnectedAccountUser [Section titled “verifyConnectedAccountUser”](#verifyconnectedaccountuser) classActionsClienthttps\://github.com/scalekit-inc/scalekit-sdk-node/blob/main/src/actions.ts ### listConnectedAccounts [Section titled “listConnectedAccounts”](#listconnectedaccounts) classActionsClienthttps\://github.com/scalekit-inc/scalekit-sdk-node/blob/main/src/actions.ts ### executeTool [Section titled “executeTool”](#executetool) classActionsClienthttps\://github.com/scalekit-inc/scalekit-sdk-node/blob/main/src/actions.ts ### getAuthorizationLink [Section titled “getAuthorizationLink”](#getauthorizationlink) classActionsClienthttps\://github.com/scalekit-inc/scalekit-sdk-node/blob/main/src/actions.ts ### listConnections [Section titled “listConnections”](#listconnections) classActionsClienthttps\://github.com/scalekit-inc/scalekit-sdk-node/blob/main/src/actions.ts ### deleteConnectedAccount [Section titled “deleteConnectedAccount”](#deleteconnectedaccount) classActionsClienthttps\://github.com/scalekit-inc/scalekit-sdk-node/blob/main/src/actions.ts ### getConnectedAccount [Section titled “getConnectedAccount”](#getconnectedaccount) classActionsClienthttps\://github.com/scalekit-inc/scalekit-sdk-node/blob/main/src/actions.ts ### createConnectedAccount [Section titled “createConnectedAccount”](#createconnectedaccount) classActionsClienthttps\://github.com/scalekit-inc/scalekit-sdk-node/blob/main/src/actions.ts ### getOrCreateConnectedAccount [Section titled “getOrCreateConnectedAccount”](#getorcreateconnectedaccount) classActionsClienthttps\://github.com/scalekit-inc/scalekit-sdk-node/blob/main/src/actions.ts ### updateConnectedAccount [Section titled “updateConnectedAccount”](#updateconnectedaccount) classActionsClienthttps\://github.com/scalekit-inc/scalekit-sdk-node/blob/main/src/actions.ts ### request [Section titled “request”](#request) classActionsClienthttps\://github.com/scalekit-inc/scalekit-sdk-node/blob/main/src/actions.ts --- # DOCUMENT BOUNDARY --- # Error handling > Catch Scalekit exceptions from AgentKit calls and handle not-found, auth, and server failures AgentKit methods on `scalekit.actions` and `scalekit.tools` throw typed exceptions when the API returns an error. Catch the specific type first, then fall back to the base server exception. ## Catch exceptions [Section titled “Catch exceptions”](#catch-exceptions) ```ts import { ScalekitNotFoundException, ScalekitUnauthorizedException, ScalekitForbiddenException, ScalekitServerException, } from '@scalekit-sdk/node' try { const account = await scalekit.actions.getConnectedAccount({ connectionName: 'gmail', identifier: 'user@example.com', }) } catch (err) { if (err instanceof ScalekitNotFoundException) { // No connected account yet — create one or send the user through OAuth } else if (err instanceof ScalekitUnauthorizedException) { // Invalid or expired client credentials / tokens } else if (err instanceof ScalekitForbiddenException) { // Caller is authenticated but not allowed for this resource } else if (err instanceof ScalekitServerException) { // Unexpected API or platform error — log status and code console.error(err.message) } else { throw err } } ``` ## Exception types [Section titled “Exception types”](#exception-types) | Exception | When it is raised | Typical response | | ------------------------------- | --------------------------------------------------------- | ----------------------------------------------------------- | | `ScalekitNotFoundException` | Resource does not exist (connected account, tool, config) | Create the resource or return a clear not-found to the user | | `ScalekitUnauthorizedException` | Missing or invalid credentials | Refresh tokens or fix client ID/secret | | `ScalekitForbiddenException` | Authenticated but not permitted | Adjust scopes, org, or role | | `ScalekitServerException` | Base class for Scalekit HTTP/API failures | Log, retry when safe, surface a generic error | `ScalekitServerException` is the base type. Prefer checking subclasses first so not-found and auth failures get the right UX. ## Related [Section titled “Related”](#related) * [Connected accounts](/agentkit/sdks/node/actions/) — connect accounts and execute tools * [Tool calling](/agentkit/sdks/node/tools/) — list tool definitions * [Install](/agentkit/sdks/node/) — create the Scalekit client --- # DOCUMENT BOUNDARY --- # Tool calling > List raw tool schemas for custom adapters `scalekit.tools` returns raw tool schemas so you can build custom agent adapters instead of using `scalekit.actions.executeTool` directly. Use this client when you need tool definitions (name, parameters, connector) for frameworks or your own executor. For connect + execute flows, prefer [Connected accounts](/agentkit/sdks/node/actions/). See [Error handling](/agentkit/sdks/node/errors/) for exceptions. ### listTools [Section titled “listTools”](#listtools) classToolsClienthttps\://github.com/scalekit-inc/scalekit-sdk-node/blob/main/src/tools.ts ### listScopedTools [Section titled “listScopedTools”](#listscopedtools) classToolsClienthttps\://github.com/scalekit-inc/scalekit-sdk-node/blob/main/src/tools.ts ### listAvailableTools [Section titled “listAvailableTools”](#listavailabletools) classToolsClienthttps\://github.com/scalekit-inc/scalekit-sdk-node/blob/main/src/tools.ts ### executeTool [Section titled “executeTool”](#executetool) classToolsClienthttps\://github.com/scalekit-inc/scalekit-sdk-node/blob/main/src/tools.ts --- # DOCUMENT BOUNDARY --- # Python SDK > Install and initialize the Scalekit Python SDK for AgentKit. Install the Python SDK, create a `ScalekitClient`, then use the sidebar for AgentKit clients. * **Connections** (`scalekit_client.connection`) — create, list, get, and update environment-level connections * **Connected accounts** (`scalekit_client.actions`) — connect end-user accounts and execute tools * **Tool calling** — raw tool definitions for custom adapters * **MCP server**, **Frameworks**, **Request modifiers**, **Custom OAuth** — advanced surfaces * **Error handling** — typed exceptions for API failures ## Install [Section titled “Install”](#install) **Requires Python 3.8 or later.** The public SDK on PyPI does not support Python 3.5–3.7. If you run a legacy Python environment, contact [support](mailto:support@scalekit.com) to discuss alternatives. ```bash 1 pip install scalekit-sdk-python ``` ## Initialize [Section titled “Initialize”](#initialize) ```python import os from scalekit import ScalekitClient scalekit_client = ScalekitClient( env_url=os.environ["SCALEKIT_ENVIRONMENT_URL"], client_id=os.environ["SCALEKIT_CLIENT_ID"], client_secret=os.environ["SCALEKIT_CLIENT_SECRET"], ) actions = scalekit_client.actions ``` ## Next steps [Section titled “Next steps”](#next-steps) * [Connections](/agentkit/sdks/python/connections/) * [Connected accounts](/agentkit/sdks/python/actions/) * [Tool calling](/agentkit/sdks/python/tools/) * [MCP](/agentkit/sdks/python/mcp/) * [Framework adapters](/agentkit/sdks/python/framework-adapters/) * [Error handling](/agentkit/sdks/python/errors/) --- # DOCUMENT BOUNDARY --- # Connected accounts > Connect accounts, start auth, and execute tools with scalekit.actions `scalekit.actions` is the primary AgentKit client for connecting end-user accounts, starting OAuth, and executing tools on their behalf. **Common path:** create or look up a connected account → get an authorization link → verify the user after redirect → run tools. For raw tool schemas, see [Tool calling](/agentkit/sdks/python/tools/). For exceptions, see [Error handling](/agentkit/sdks/python/errors/). ### get\_authorization\_link [Section titled “get\_authorization\_link”](#get_authorization_link) classActionsClient ### verify\_connected\_account\_user [Section titled “verify\_connected\_account\_user”](#verify_connected_account_user) classActionsClient ### get\_or\_create\_connected\_account [Section titled “get\_or\_create\_connected\_account”](#get_or_create_connected_account) classActionsClient ### get\_connected\_account [Section titled “get\_connected\_account”](#get_connected_account) classActionsClient ### get\_connected\_account\_details [Section titled “get\_connected\_account\_details”](#get_connected_account_details) classActionsClient ### list\_connected\_accounts [Section titled “list\_connected\_accounts”](#list_connected_accounts) classActionsClient ### create\_connected\_account [Section titled “create\_connected\_account”](#create_connected_account) classActionsClient ### update\_connected\_account [Section titled “update\_connected\_account”](#update_connected_account) classActionsClient ### delete\_connected\_account [Section titled “delete\_connected\_account”](#delete_connected_account) classActionsClient ### execute\_tool [Section titled “execute\_tool”](#execute_tool) classActionsClient ### request [Section titled “request”](#request) classActionsClient --- # DOCUMENT BOUNDARY --- # Connections > Manage environment-level AgentKit connections with scalekit_client.connection `scalekit_client.connection` manages the environment-level connections that AgentKit connectors run on. A connection holds the OAuth app credentials, scopes, and redirect URI Scalekit uses when your users authorize a connector, and one connection serves every user in that environment. **Common path:** create the connection once → attach OAuth credentials with `update_environment_connection` → connect end-user accounts with [`scalekit_client.actions`](/agentkit/sdks/python/actions/) → run tools. Most teams create connections in the Scalekit Dashboard — see [Configure a connection](/agentkit/connections/). Use these methods when you provision or manage environments in code, such as seeding a new environment from a setup script or CI job. These methods cover environment-level **app** connections (`Flags(is_app=True)`). Organization-scoped SSO connection APIs stay on the [SaaSKit connection reference](/saaskit/sdks/python/connection/). ### create\_environment\_connection [Section titled “create\_environment\_connection”](#create_environment_connection) clientConnectionhttps\://github.com/scalekit-inc/scalekit-sdk-python/blob/main/scalekit/connection.py ### list\_app\_connections [Section titled “list\_app\_connections”](#list_app_connections) clientConnectionhttps\://github.com/scalekit-inc/scalekit-sdk-python/blob/main/scalekit/connection.py ### get\_environment\_connection [Section titled “get\_environment\_connection”](#get_environment_connection) clientConnectionhttps\://github.com/scalekit-inc/scalekit-sdk-python/blob/main/scalekit/connection.py ### update\_environment\_connection [Section titled “update\_environment\_connection”](#update_environment_connection) clientConnectionhttps\://github.com/scalekit-inc/scalekit-sdk-python/blob/main/scalekit/connection.py ## Next steps [Section titled “Next steps”](#next-steps) * [Connected accounts](/agentkit/sdks/python/actions/) — connect end-user accounts and run tools on their behalf * [Configure a connection](/agentkit/connections/) — create connections in the Scalekit Dashboard --- # DOCUMENT BOUNDARY --- # Custom OAuth > AgentKit custom providers `actions.providers` manages custom providers used with bring-your-own connectors. Methods take typed request objects and return typed responses. Working end-to-end examples for OAuth, API key, bearer, and other auth types live in the [custom connectors demos](https://github.com/scalekit-inc/python-connect-demos/tree/main/custom-connectors) repo. Use those samples for field-complete setup rather than partial request shapes here. See [Bring your own connector](/agentkit/bring-your-own-connector/overview/) for the product flow. | Method | Purpose | | ------------------------------------------ | ---------------------------------------------------------------------------- | | `actions.providers.create_custom_provider` | Create a custom provider (`CreateCustomProviderRequest`) | | `actions.providers.update_custom_provider` | Partial update (`UpdateCustomProviderRequest`; only non-`None` fields apply) | | `actions.providers.list_providers` | List or filter providers (`ListProvidersRequest`) | | `actions.providers.delete_custom_provider` | Permanent delete by identifier (`DeleteCustomProviderRequest`) | *** --- # DOCUMENT BOUNDARY --- # Error handling > Catch Scalekit exceptions from AgentKit calls and handle not-found, auth, and server failures AgentKit methods throw typed exceptions when the API returns an error. Catch the specific type first, then fall back to the base server exception. ## Catch exceptions [Section titled “Catch exceptions”](#catch-exceptions) ```python from scalekit.common.exceptions import ( ScalekitNotFoundException, ScalekitUnauthorizedException, ScalekitForbiddenException, ScalekitServerException, ) try: account = scalekit_client.actions.get_connected_account( connection_name="gmail", identifier="user@example.com", ) except ScalekitNotFoundException: # No connected account yet — create one or send the user through OAuth pass except ScalekitUnauthorizedException: # Invalid or expired client credentials / tokens pass except ScalekitForbiddenException: # Caller is authenticated but not allowed for this resource pass except ScalekitServerException as e: # Unexpected API or platform error print(e.error_code, e.http_status) ``` ## Exception types [Section titled “Exception types”](#exception-types) | Exception | When it is raised | Typical response | | ------------------------------- | --------------------------------------------------------- | ----------------------------------------------------------- | | `ScalekitNotFoundException` | Resource does not exist (connected account, tool, config) | Create the resource or return a clear not-found to the user | | `ScalekitUnauthorizedException` | Missing or invalid credentials | Refresh tokens or fix client ID/secret | | `ScalekitForbiddenException` | Authenticated but not permitted | Adjust scopes, org, or role | | `ScalekitServerException` | Base class for Scalekit HTTP/API failures | Log, retry when safe, surface a generic error | `ScalekitServerException` is the base type. Prefer checking subclasses first so not-found and auth failures get the right UX. ## Related [Section titled “Related”](#related) * [Connected accounts](/agentkit/sdks/python/actions/) — connect accounts and execute tools * [Tool calling](/agentkit/sdks/python/tools/) — list tool definitions * [Install](/agentkit/sdks/python/) — create the Scalekit client --- # DOCUMENT BOUNDARY --- # Frameworks > Adapters for agent frameworks Framework adapters map Scalekit tools into popular agent frameworks so you can register tools without hand-writing schema conversion. Pick the adapter for your stack, pass the Scalekit client, and register tools on the agent. See [Connected accounts](/agentkit/sdks/python/actions/) for the underlying client and [Error handling](/agentkit/sdks/python/errors/) for exceptions. ### actions.langchain.get\_tools [Section titled “actions.langchain.get\_tools”](#actionslangchainget_tools) classLangChainhttps\://github.com/scalekit-inc/scalekit-sdk-python/blob/main/scalekit/actions/frameworks/langchain.py --- # DOCUMENT BOUNDARY --- # MCP configurations > Expose AgentKit tools over MCP. Expose AgentKit tools over MCP so hosts like Claude Desktop or Cursor can call connected-account tools through a standard protocol. Configure an MCP server, attach connected accounts, and issue tokens for clients. See [Error handling](/agentkit/sdks/python/errors/) for API exceptions. ### scalekit\_client.actions.mcp.create\_config [Section titled “scalekit\_client.actions.mcp.create\_config”](#scalekit_clientactionsmcpcreate_config) classMcpClient ### scalekit\_client.actions.mcp.list\_configs [Section titled “scalekit\_client.actions.mcp.list\_configs”](#scalekit_clientactionsmcplist_configs) classMcpClient ### scalekit\_client.actions.mcp.update\_config [Section titled “scalekit\_client.actions.mcp.update\_config”](#scalekit_clientactionsmcpupdate_config) classMcpClient ### scalekit\_client.actions.mcp.delete\_config [Section titled “scalekit\_client.actions.mcp.delete\_config”](#scalekit_clientactionsmcpdelete_config) classMcpClient ### scalekit\_client.actions.mcp.list\_mcp\_connected\_accounts [Section titled “scalekit\_client.actions.mcp.list\_mcp\_connected\_accounts”](#scalekit_clientactionsmcplist_mcp_connected_accounts) classMcpClient ### scalekit\_client.actions.mcp.create\_session\_token [Section titled “scalekit\_client.actions.mcp.create\_session\_token”](#scalekit_clientactionsmcpcreate_session_token) classMcpClient --- # DOCUMENT BOUNDARY --- # Request modifiers > AgentKit modifiers Modifiers intercept tool calls to transform inputs or outputs, useful for validation, enrichment, or logging. ```python 1 # actions comes from the Scalekit client (or your framework adapter) 2 actions = scalekit_client.actions 3 4 @actions.pre_modifier(tool_names=["gmail_fetch_emails"]) 5 def add_default_label(tool_input): 6 tool_input.setdefault("label", "UNREAD") 7 return tool_input 8 9 @actions.post_modifier(tool_names=["gmail_fetch_emails"]) 10 def filter_attachments(tool_output): 11 tool_output["emails"] = [e for e in tool_output["emails"] if not e.get("has_attachment")] 12 return tool_output ``` | Decorator | Receives | Returns | | ------------------------------------ | -------- | --------------- | | `@actions.pre_modifier(tool_names)` | `dict` | Modified `dict` | | `@actions.post_modifier(tool_names)` | `dict` | Modified `dict` | `tool_names` accepts a string or a list of strings. Multiple modifiers for the same tool chain in registration order. *** --- # DOCUMENT BOUNDARY --- # Tool calling > List raw tool schemas for custom adapters `scalekit.tools` returns raw tool schemas for custom agent adapters. Use this when you need tool definitions for frameworks or your own executor. For connect + execute, use [Connected accounts](/agentkit/sdks/python/actions/). See [Error handling](/agentkit/sdks/python/errors/). ### tools.list\_tools [Section titled “tools.list\_tools”](#toolslist_tools) classToolsClient ### tools.list\_scoped\_tools [Section titled “tools.list\_scoped\_tools”](#toolslist_scoped_tools) classToolsClient ### tools.execute\_tool [Section titled “tools.execute\_tool”](#toolsexecute_tool) classToolsClient --- # DOCUMENT BOUNDARY --- # Authorize a user > Generate an authorization link, send it to your user, and confirm their connected account is active before your agent executes tools. Once a connection is configured, your users need to grant your agent access to their account. This happens once per user per connection. Scalekit stores their tokens and keeps them fresh automatically. The flow is: 1. Create a connected account for the user 2. Generate an authorization link and send it to the user 3. The user completes the OAuth consent screen 4. The connected account becomes `ACTIVE`. Your agent can now execute tools. ## Create a connected account and generate a link [Section titled “Create a connected account and generate a link”](#create-a-connected-account-and-generate-a-link) * Python ```python 1 # Create or retrieve the connected account for this user 2 response = actions.get_or_create_connected_account( 3 connection_name="github-connect", 4 identifier="user_123" # your app's unique user ID 5 ) 6 connected_account = response.connected_account 7 8 # Generate the authorization link if the account is not yet active 9 if connected_account.status != "ACTIVE": 10 link_response = actions.get_authorization_link( 11 connection_name="github-connect", 12 identifier="user_123" 13 ) 14 auth_url = link_response.link 15 # Redirect or send auth_url to the user ``` * Node.js ```typescript 1 import { ConnectorStatus } from '@scalekit-sdk/node/lib/pkg/grpc/scalekit/v1/connected_accounts/connected_accounts_pb'; 2 3 // Create or retrieve the connected account for this user 4 const response = await actions.getOrCreateConnectedAccount({ 5 connectionName: 'github-connect', 6 identifier: 'user_123', // your app's unique user ID 7 }); 8 9 const connectedAccount = response.connectedAccount; 10 11 // Generate the authorization link if the account is not yet active 12 if (connectedAccount?.status !== ConnectorStatus.ACTIVE) { 13 const linkResponse = await actions.getAuthorizationLink({ 14 connectionName: 'github-connect', 15 identifier: 'user_123', 16 }); 17 const authUrl = linkResponse.link; 18 // Redirect or send authUrl to the user 19 } ``` ## Send the link to the user [Section titled “Send the link to the user”](#send-the-link-to-the-user) How you deliver the link depends on your application: * **Web app:** redirect the user to `auth_url` directly if they’re in an active browser session * **Email or notification:** send the link when the user isn’t actively in your app, or when connecting at their own pace is acceptable * **In-app prompt:** show a button (“Connect GitHub”) when you want to prompt connection at a specific moment in the user’s workflow Once the user opens the link and approves the OAuth consent screen, Scalekit exchanges the authorization code for tokens and marks the connected account `ACTIVE`. You do not need to handle the OAuth callback yourself. ## Check status and re-authorize [Section titled “Check status and re-authorize”](#check-status-and-re-authorize) Check the connected account status before executing tools. Tokens can expire or be revoked, so generate a new authorization link using the same flow when that happens. * Python ```python 1 response = actions.get_or_create_connected_account( 2 connection_name="github-connect", 3 identifier="user_123" 4 ) 5 connected_account = response.connected_account 6 # ACTIVE: ready for tool calls 7 # PENDING: user has not completed the OAuth flow 8 # EXPIRED: tokens expired, re-authorization required 9 # REVOKED: user revoked access from the provider 10 11 if connected_account.status != "ACTIVE": 12 link_response = actions.get_authorization_link( 13 connection_name="github-connect", 14 identifier="user_123" 15 ) 16 # Redirect or send link_response.link to the user ``` * Node.js ```typescript 1 import { ConnectorStatus } from '@scalekit-sdk/node/lib/pkg/grpc/scalekit/v1/connected_accounts/connected_accounts_pb'; 2 3 const response = await actions.getOrCreateConnectedAccount({ 4 connectionName: 'github-connect', 5 identifier: 'user_123', 6 }); 7 8 const connectedAccount = response.connectedAccount; 9 // ACTIVE: ready for tool calls 10 // PENDING: user has not completed the OAuth flow 11 // EXPIRED: tokens expired, re-authorization required 12 // REVOKED: user revoked access from the provider 13 14 if (connectedAccount?.status !== ConnectorStatus.ACTIVE) { 15 const linkResponse = await actions.getAuthorizationLink({ 16 connectionName: 'github-connect', 17 identifier: 'user_123', 18 }); 19 // Redirect or send linkResponse.link to the user 20 } ``` --- # DOCUMENT BOUNDARY --- # Pre and Post Processors > Learn how to create pre and post processor workflows that are run before or after tool execution with Agent Auth. Custom pre and post processors are a way to create custom workflows that are run before or after tool execution with Agent Auth. They are useful for: * Validating and transforming input data * Processing and Formatting output data * Adding additional context to the tool execution ## Usage [Section titled “Usage”](#usage) --- # DOCUMENT BOUNDARY --- # Custom tools > Build tools that Scalekit does not provide out of the box by proxying provider API calls through connected accounts. When you need a connector tool that Scalekit doesn’t offer as a pre-built tool, use **API Proxy mode**. You define the tool contract and call the provider endpoint through `actions.request`. Scalekit injects the user’s credentials from their connected account; your agent never handles raw tokens. | Option | Best for | Who defines tool schema | | ------------------------ | --------------------------------- | ----------------------- | | Scalekit optimized tools | Common connector tools | Scalekit | | Custom tools (API Proxy) | Unsupported or app-specific tools | Your application | This page assumes the user has an `ACTIVE` connected account. If not, see [Authorize a user](/agentkit/tools/authorize/). ## Find the right endpoint [Section titled “Find the right endpoint”](#find-the-right-endpoint) The `path` you pass to `actions.request` is forwarded directly to the provider’s API; Scalekit only adds authentication headers. Look up the provider’s API reference to get the correct path, method, and request shape. | Connector | API reference | | ---------- | ------------------------------------------------------------------------------------------------ | | Gmail | [Google Gmail API](https://developers.google.com/gmail/api/reference/rest) | | Slack | [Slack API methods](https://api.slack.com/methods) | | GitHub | [GitHub REST API](https://docs.github.com/en/rest) | | Salesforce | [Salesforce REST API](https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/) | | HubSpot | [HubSpot API](https://developers.hubspot.com/docs/api/overview) | ## Define your tool contract [Section titled “Define your tool contract”](#define-your-tool-contract) Design the tool around your agent’s intent, not the provider’s API surface. For example, to list Gmail filters: * **Tool name:** `gmail_list_filters` (describes the action, not the endpoint) * **Input:** `identifier` (your app’s user ID) * **Output:** `{ filters: [...], count: N }` (structured, not the raw Gmail response) Keep schemas focused on what the model needs. Strip provider-specific noise before returning data. ## Proxy the API call [Section titled “Proxy the API call”](#proxy-the-api-call) Use `actions.request` to call any provider endpoint. Scalekit handles credential injection. **GET requests:** pass query parameters as a dict: * Python ```python 1 def gmail_list_filters(identifier: str): 2 response = actions.request( 3 connection_name="gmail", 4 identifier=identifier, 5 method="GET", 6 path="/gmail/v1/users/me/settings/filters", 7 ) 8 data = response.json() 9 return {"filters": data.get("filter", []), "count": len(data.get("filter", []))} 10 11 def gmail_list_unread(identifier: str, max_results: int = 10): 12 response = actions.request( 13 connection_name="gmail", 14 identifier=identifier, 15 method="GET", 16 path="/gmail/v1/users/me/messages", 17 query_params={"q": "is:unread", "maxResults": max_results}, 18 ) 19 return {"messages": response.json().get("messages", [])} ``` * Node.js ```typescript 1 async function gmailListFilters(identifier: string) { 2 const response = await scalekit.actions.request({ 3 connectionName: 'gmail', 4 identifier, 5 method: 'GET', 6 path: '/gmail/v1/users/me/settings/filters', 7 }); 8 const filters = response.data?.filter ?? []; 9 return { filters, count: filters.length }; 10 } 11 12 async function gmailListUnread(identifier: string, maxResults = 10) { 13 const response = await scalekit.actions.request({ 14 connectionName: 'gmail', 15 identifier, 16 method: 'GET', 17 path: '/gmail/v1/users/me/messages', 18 queryParams: { q: 'is:unread', maxResults }, 19 }); 20 return { messages: response.data?.messages ?? [] }; 21 } ``` **POST requests:** pass a body for write operations: * Python ```python 1 def slack_send_message(identifier: str, channel: str, text: str): 2 response = actions.request( 3 connection_name="slack", 4 identifier=identifier, 5 method="POST", 6 path="/api/chat.postMessage", 7 body={"channel": channel, "text": text}, 8 ) 9 data = response.json() 10 if not data.get("ok"): 11 raise ValueError(f"Slack error: {data.get('error')}") 12 return {"ts": data.get("ts"), "channel": data.get("channel")} ``` * Node.js ```typescript 1 async function slackSendMessage(identifier: string, channel: string, text: string) { 2 const response = await scalekit.actions.request({ 3 connectionName: 'slack', 4 identifier, 5 method: 'POST', 6 path: '/api/chat.postMessage', 7 body: { channel, text }, 8 }); 9 if (!response.data?.ok) throw new Error(`Slack error: ${response.data?.error}`); 10 return { ts: response.data.ts, channel: response.data.channel }; 11 } ``` ## Check authorization before proxy calls [Section titled “Check authorization before proxy calls”](#check-authorization-before-proxy-calls) Verify the connected account is `ACTIVE` before making a proxy call and handle provider errors explicitly: * Python ```python 1 account = actions.get_or_create_connected_account( 2 connection_name="gmail", 3 identifier=identifier, 4 ).connected_account 5 6 if account.status != "ACTIVE": 7 raise ValueError("Connected account is not ACTIVE. Re-authorize the user.") ``` * Node.js ```typescript 1 import { ConnectorStatus } from '@scalekit-sdk/node/lib/pkg/grpc/scalekit/v1/connected_accounts/connected_accounts_pb'; 2 3 const account = (await scalekit.actions.getOrCreateConnectedAccount({ 4 connectionName: 'gmail', 5 identifier, 6 })).connectedAccount; 7 8 if (account?.status !== ConnectorStatus.ACTIVE) { 9 throw new Error('Connected account is not ACTIVE. Re-authorize the user.'); 10 } ``` ## Best practices [Section titled “Best practices”](#best-practices) * Expose only the fields your model needs; keep schemas small * Validate inputs server-side; never trust model-generated parameters * Use predictable JSON keys; return stable output across calls * Map provider errors to clear tool errors; don’t leak raw provider payloads to prompts --- # DOCUMENT BOUNDARY --- # Proxy Tools > Learn how to make direct API calls to providers using Agent Auth's proxy tools. Custom tool definitions allow you to create specialized tools tailored to your specific business needs. You can combine multiple provider tools, add custom logic, and create reusable workflows that go beyond standard tool functionality. ## What are custom tools? [Section titled “What are custom tools?”](#what-are-custom-tools) Custom tools are user-defined functions that: * **Extend existing tools**: Build on top of standard provider tools * **Combine multiple operations**: Create workflows that use multiple tools * **Add business logic**: Include custom validation, processing, and formatting * **Create reusable patterns**: Standardize common operations across your team * **Integrate with external systems**: Connect to your own APIs and services ## Custom tool structure [Section titled “Custom tool structure”](#custom-tool-structure) Every custom tool follows a standardized structure: ```javascript 1 { 2 name: 'custom_tool_name', 3 display_name: 'Custom Tool Display Name', 4 description: 'Description of what the tool does', 5 category: 'custom', 6 provider: 'custom', 7 input_schema: { 8 type: 'object', 9 properties: { 10 // Define input parameters 11 }, 12 required: ['required_param'] 13 }, 14 output_schema: { 15 type: 'object', 16 properties: { 17 // Define output format 18 } 19 }, 20 implementation: async (parameters, context) => { 21 // Custom tool logic 22 return result; 23 } 24 } ``` ## Creating custom tools [Section titled “Creating custom tools”](#creating-custom-tools) ### Basic custom tool [Section titled “Basic custom tool”](#basic-custom-tool) Here’s a simple custom tool that sends a welcome email: ```javascript 1 const sendWelcomeEmail = { 2 name: 'send_welcome_email', 3 display_name: 'Send Welcome Email', 4 description: 'Send a personalized welcome email to new users', 5 category: 'communication', 6 provider: 'custom', 7 input_schema: { 8 type: 'object', 9 properties: { 10 user_name: { 11 type: 'string', 12 description: 'Name of the new user' 13 }, 14 user_email: { 15 type: 'string', 16 format: 'email', 17 description: 'Email address of the new user' 18 }, 19 company_name: { 20 type: 'string', 21 description: 'Name of the company' 22 } 23 }, 24 required: ['user_name', 'user_email', 'company_name'] 25 }, 26 output_schema: { 27 type: 'object', 28 properties: { 29 message_id: { 30 type: 'string', 31 description: 'ID of the sent email' 32 }, 33 status: { 34 type: 'string', 35 enum: ['sent', 'failed'], 36 description: 'Status of the email' 37 } 38 } 39 }, 40 implementation: async (parameters, context) => { 41 const { user_name, user_email, company_name } = parameters; 42 43 // Generate personalized email content 44 const emailBody = ` 45 Welcome to ${company_name}, ${user_name}! 46 47 We're excited to have you join our team. Here are some next steps: 48 49 1. Complete your profile setup 50 2. Join our Slack workspace 51 3. Schedule a meeting with your manager 52 53 If you have any questions, don't hesitate to reach out! 54 55 Best regards, 56 The ${company_name} Team 57 `; 58 59 // Send email using standard email tool 60 const result = await context.tools.execute({ 61 tool: 'send_email', 62 parameters: { 63 to: [user_email], 64 subject: `Welcome to ${company_name}!`, 65 body: emailBody 66 } 67 }); 68 69 return { 70 message_id: result.message_id, 71 status: result.status === 'sent' ? 'sent' : 'failed' 72 }; 73 } 74 }; ``` ### Multi-step workflow tool [Section titled “Multi-step workflow tool”](#multi-step-workflow-tool) Create a tool that combines multiple operations: ```javascript 1 const createProjectWorkflow = { 2 name: 'create_project_workflow', 3 display_name: 'Create Project Workflow', 4 description: 'Create a complete project setup with Jira project, Slack channel, and team notifications', 5 category: 'project_management', 6 provider: 'custom', 7 input_schema: { 8 type: 'object', 9 properties: { 10 project_name: { 11 type: 'string', 12 description: 'Name of the project' 13 }, 14 project_key: { 15 type: 'string', 16 description: 'Project key for Jira' 17 }, 18 team_members: { 19 type: 'array', 20 items: { type: 'string', format: 'email' }, 21 description: 'Team member email addresses' 22 }, 23 project_description: { 24 type: 'string', 25 description: 'Project description' 26 } 27 }, 28 required: ['project_name', 'project_key', 'team_members'] 29 }, 30 output_schema: { 31 type: 'object', 32 properties: { 33 jira_project_id: { type: 'string' }, 34 slack_channel_id: { type: 'string' }, 35 notifications_sent: { type: 'number' } 36 } 37 }, 38 implementation: async (parameters, context) => { 39 const { project_name, project_key, team_members, project_description } = parameters; 40 41 try { 42 // Step 1: Create Jira project 43 const jiraProject = await context.tools.execute({ 44 tool: 'create_jira_project', 45 parameters: { 46 key: project_key, 47 name: project_name, 48 description: project_description, 49 project_type: 'software' 50 } 51 }); 52 53 // Step 2: Create Slack channel 54 const slackChannel = await context.tools.execute({ 55 tool: 'create_channel', 56 parameters: { 57 name: `${project_key.toLowerCase()}-team`, 58 topic: `Discussion for ${project_name}`, 59 is_private: false 60 } 61 }); 62 63 // Step 3: Send notifications to team members 64 let notificationCount = 0; 65 for (const member of team_members) { 66 try { 67 await context.tools.execute({ 68 tool: 'send_email', 69 parameters: { 70 to: [member], 71 subject: `New Project: ${project_name}`, 72 body: ` 73 You've been added to the new project "${project_name}". 74 75 Jira Project: ${jiraProject.project_url} 76 Slack Channel: #${slackChannel.channel_name} 77 78 Please join the Slack channel to start collaborating! 79 ` 80 } 81 }); 82 notificationCount++; 83 } catch (error) { 84 console.error(`Failed to send notification to ${member}:`, error); 85 } 86 } 87 88 // Step 4: Post welcome message to Slack channel 89 await context.tools.execute({ 90 tool: 'send_message', 91 parameters: { 92 channel: `#${slackChannel.channel_name}`, 93 text: `<� Welcome to ${project_name}! This channel is for project discussion and updates.` 94 } 95 }); 96 97 return { 98 jira_project_id: jiraProject.project_id, 99 slack_channel_id: slackChannel.channel_id, 100 notifications_sent: notificationCount 101 }; 102 103 } catch (error) { 104 throw new Error(`Project creation failed: ${error.message}`); 105 } 106 } 107 }; ``` ### Data processing tool [Section titled “Data processing tool”](#data-processing-tool) Create a tool that processes and analyzes data: ```javascript 1 const generateTeamReport = { 2 name: 'generate_team_report', 3 display_name: 'Generate Team Report', 4 description: 'Generate a comprehensive team performance report from multiple sources', 5 category: 'analytics', 6 provider: 'custom', 7 input_schema: { 8 type: 'object', 9 properties: { 10 team_members: { 11 type: 'array', 12 items: { type: 'string', format: 'email' }, 13 description: 'Team member email addresses' 14 }, 15 start_date: { 16 type: 'string', 17 format: 'date', 18 description: 'Report start date' 19 }, 20 end_date: { 21 type: 'string', 22 format: 'date', 23 description: 'Report end date' 24 }, 25 include_calendar: { 26 type: 'boolean', 27 default: true, 28 description: 'Include calendar analysis' 29 } 30 }, 31 required: ['team_members', 'start_date', 'end_date'] 32 }, 33 output_schema: { 34 type: 'object', 35 properties: { 36 report_url: { type: 'string' }, 37 summary: { type: 'object' }, 38 sent_to: { type: 'array', items: { type: 'string' } } 39 } 40 }, 41 implementation: async (parameters, context) => { 42 const { team_members, start_date, end_date, include_calendar } = parameters; 43 44 // Fetch Jira issues assigned to team members 45 const jiraIssues = await context.tools.execute({ 46 tool: 'fetch_issues', 47 parameters: { 48 jql: `assignee in (${team_members.join(',')}) AND created >= ${start_date} AND created <= ${end_date}`, 49 fields: ['summary', 'status', 'assignee', 'created', 'resolved'] 50 } 51 }); 52 53 // Fetch calendar events if requested 54 let calendarData = null; 55 if (include_calendar) { 56 calendarData = await context.tools.execute({ 57 tool: 'fetch_events', 58 parameters: { 59 start_date: start_date, 60 end_date: end_date, 61 attendees: team_members 62 } 63 }); 64 } 65 66 // Process and analyze data 67 const report = { 68 period: { start_date, end_date }, 69 team_size: team_members.length, 70 issues: { 71 total: jiraIssues.issues.length, 72 completed: jiraIssues.issues.filter(i => i.status === 'Done').length, 73 in_progress: jiraIssues.issues.filter(i => i.status === 'In Progress').length 74 }, 75 meetings: calendarData ? { 76 total: calendarData.events.length, 77 hours: calendarData.events.reduce((acc, event) => acc + event.duration, 0) 78 } : null 79 }; 80 81 // Generate HTML report 82 const htmlReport = ` 83 84 Team Report - ${start_date} to ${end_date} 85 86

Team Performance Report

Summary

Team Size: ${report.team_size}

Total Issues: ${report.issues.total}

Completed Issues: ${report.issues.completed}

In Progress: ${report.issues.in_progress}

92 ${report.meetings ? `

Total Meetings: ${report.meetings.total}

` : ''} 93 94 95 `; 96 97 // Send report via email 98 const emailResults = await Promise.all( 99 team_members.map(member => 100 context.tools.execute({ 101 tool: 'send_email', 102 parameters: { 103 to: [member], 104 subject: `Team Report - ${start_date} to ${end_date}`, 105 html_body: htmlReport 106 } 107 }) 108 ) 109 ); 110 111 return { 112 report_url: 'Generated and sent via email', 113 summary: report, 114 sent_to: team_members.filter((_, index) => emailResults[index].status === 'sent') 115 }; 116 } 117 }; ``` ## Registering custom tools [Section titled “Registering custom tools”](#registering-custom-tools) ### Using the API [Section titled “Using the API”](#using-the-api) Register your custom tools with Agent Auth: * JavaScript ```javascript 1 // Register a custom tool 2 const registeredTool = await agentConnect.tools.register({ 3 ...sendWelcomeEmail, 4 organization_id: 'your_org_id' 5 }); 6 7 console.log('Tool registered:', registeredTool.id); ``` * Python ```python 1 # Register a custom tool 2 registered_tool = agent_connect.tools.register( 3 **send_welcome_email, 4 organization_id='your_org_id' 5 ) 6 7 print(f'Tool registered: {registered_tool.id}') ``` * cURL ```bash 1 curl -X POST "${SCALEKIT_BASE_URL}/v1/connect/tools/custom" \ 2 -H "Authorization: Bearer ${SCALEKIT_CLIENT_SECRET}" \ 3 -H "Content-Type: application/json" \ 4 -d '{ 5 "name": "send_welcome_email", 6 "display_name": "Send Welcome Email", 7 "description": "Send a personalized welcome email to new users", 8 "category": "communication", 9 "provider": "custom", 10 "input_schema": {...}, 11 "output_schema": {...}, 12 "implementation": "async (parameters, context) => {...}" 13 }' ``` ### Using the dashboard [Section titled “Using the dashboard”](#using-the-dashboard) 1. In the [Scalekit dashboard](https://app.scalekit.com), go to **AgentKit** > **Tools** 2. Click **Create Custom Tool** 3. Fill in the tool definition form 4. Test the tool with sample parameters 5. Save and activate the tool ## Tool context and utilities [Section titled “Tool context and utilities”](#tool-context-and-utilities) The `context` object provides access to: ### Standard tools [Section titled “Standard tools”](#standard-tools) Execute any standard Agent Auth tool: ```javascript 1 // Execute standard tools 2 const result = await context.tools.execute({ 3 tool: 'send_email', 4 parameters: { ... } 5 }); 6 7 // Execute with specific connected account 8 const result = await context.tools.execute({ 9 connected_account_id: 'specific_account', 10 tool: 'send_email', 11 parameters: { ... } 12 }); ``` ### Connected accounts [Section titled “Connected accounts”](#connected-accounts) Access connected account information: ```javascript 1 // Get connected account details 2 const account = await context.accounts.get(accountId); 3 4 // List accounts for a user 5 const accounts = await context.accounts.list({ 6 identifier: 'user_123', 7 provider: 'gmail' 8 }); ``` ### Utilities [Section titled “Utilities”](#utilities) Access utility functions: ```javascript 1 // Generate unique IDs 2 const id = context.utils.generateId(); 3 4 // Format dates 5 const formatted = context.utils.formatDate(date, 'YYYY-MM-DD'); 6 7 // Validate email 8 const isValid = context.utils.isValidEmail(email); 9 10 // HTTP requests 11 const response = await context.utils.httpRequest({ 12 url: 'https://api.example.com/data', 13 method: 'GET', 14 headers: { 'Authorization': 'Bearer token' } 15 }); ``` ### Error handling [Section titled “Error handling”](#error-handling) Throw structured errors: ```javascript 1 // Throw validation error 2 throw new context.errors.ValidationError('Invalid email format'); 3 4 // Throw business logic error 5 throw new context.errors.BusinessLogicError('User not found'); 6 7 // Throw external API error 8 throw new context.errors.ExternalAPIError('GitHub API returned 500'); ``` ## Testing custom tools [Section titled “Testing custom tools”](#testing-custom-tools) ### Unit testing [Section titled “Unit testing”](#unit-testing) Test custom tools in isolation: ```javascript 1 // Mock context for testing 2 const mockContext = { 3 tools: { 4 execute: jest.fn().mockResolvedValue({ 5 message_id: 'test_msg_123', 6 status: 'sent' 7 }) 8 }, 9 utils: { 10 generateId: () => 'test_id_123', 11 formatDate: (date, format) => '2024-01-15' 12 } 13 }; 14 15 // Test custom tool 16 const result = await sendWelcomeEmail.implementation({ 17 user_name: 'John Doe', 18 user_email: 'john@example.com', 19 company_name: 'Acme Corp' 20 }, mockContext); 21 22 expect(result.status).toBe('sent'); 23 expect(mockContext.tools.execute).toHaveBeenCalledWith({ 24 tool: 'send_email', 25 parameters: expect.objectContaining({ 26 to: ['john@example.com'], 27 subject: 'Welcome to Acme Corp!' 28 }) 29 }); ``` ### Integration testing [Section titled “Integration testing”](#integration-testing) Test with real Agent Auth: ```javascript 1 // Test custom tool with real connections 2 const testResult = await agentConnect.tools.execute({ 3 connected_account_id: 'test_gmail_account', 4 tool: 'send_welcome_email', 5 parameters: { 6 user_name: 'Test User', 7 user_email: 'test@example.com', 8 company_name: 'Test Company' 9 } 10 }); 11 12 console.log('Test result:', testResult); ``` ## Best practices [Section titled “Best practices”](#best-practices) ### Tool design [Section titled “Tool design”](#tool-design) * **Single responsibility**: Each tool should have a clear, single purpose * **Consistent naming**: Use descriptive, consistent naming conventions * **Clear documentation**: Provide detailed descriptions and examples * **Error handling**: Implement comprehensive error handling * **Input validation**: Validate all input parameters ### Performance optimization [Section titled “Performance optimization”](#performance-optimization) * **Parallel execution**: Use Promise.all() for independent operations * **Caching**: Cache frequently accessed data * **Batch operations**: Group similar operations together * **Timeout handling**: Set appropriate timeouts for external calls ### Security considerations [Section titled “Security considerations”](#security-considerations) * **Input sanitization**: Sanitize all user inputs * **Permission checks**: Verify user permissions before execution * **Sensitive data**: Handle sensitive data securely * **Rate limiting**: Implement rate limiting for resource-intensive operations ## Custom tool examples [Section titled “Custom tool examples”](#custom-tool-examples) ### Slack notification tool [Section titled “Slack notification tool”](#slack-notification-tool) ```javascript 1 const sendSlackNotification = { 2 name: 'send_slack_notification', 3 display_name: 'Send Slack Notification', 4 description: 'Send formatted notifications to Slack with optional mentions', 5 category: 'communication', 6 provider: 'custom', 7 input_schema: { 8 type: 'object', 9 properties: { 10 channel: { type: 'string' }, 11 message: { type: 'string' }, 12 severity: { type: 'string', enum: ['info', 'warning', 'error'] }, 13 mentions: { type: 'array', items: { type: 'string' } } 14 }, 15 required: ['channel', 'message'] 16 }, 17 output_schema: { 18 type: 'object', 19 properties: { 20 message_ts: { type: 'string' }, 21 permalink: { type: 'string' } 22 } 23 }, 24 implementation: async (parameters, context) => { 25 const { channel, message, severity = 'info', mentions = [] } = parameters; 26 27 const colors = { 28 info: 'good', 29 warning: 'warning', 30 error: 'danger' 31 }; 32 33 const mentionText = mentions.length > 0 ? 34 `${mentions.map(m => `<@${m}>`).join(' ')} ` : ''; 35 36 return await context.tools.execute({ 37 tool: 'send_message', 38 parameters: { 39 channel, 40 text: `${mentionText}${message}`, 41 attachments: [ 42 { 43 color: colors[severity], 44 text: message, 45 ts: Math.floor(Date.now() / 1000) 46 } 47 ] 48 } 49 }); 50 } 51 }; ``` ### Calendar scheduling tool [Section titled “Calendar scheduling tool”](#calendar-scheduling-tool) ```javascript 1 const scheduleTeamMeeting = { 2 name: 'schedule_team_meeting', 3 display_name: 'Schedule Team Meeting', 4 description: 'Find available time slots and schedule team meetings', 5 category: 'scheduling', 6 provider: 'custom', 7 input_schema: { 8 type: 'object', 9 properties: { 10 attendees: { type: 'array', items: { type: 'string' } }, 11 duration: { type: 'number', minimum: 15 }, 12 preferred_times: { type: 'array', items: { type: 'string' } }, 13 meeting_title: { type: 'string' }, 14 meeting_description: { type: 'string' } 15 }, 16 required: ['attendees', 'duration', 'meeting_title'] 17 }, 18 output_schema: { 19 type: 'object', 20 properties: { 21 event_id: { type: 'string' }, 22 scheduled_time: { type: 'string' }, 23 attendees_notified: { type: 'number' } 24 } 25 }, 26 implementation: async (parameters, context) => { 27 const { attendees, duration, preferred_times, meeting_title, meeting_description } = parameters; 28 29 // Find available time slots 30 const availableSlots = await context.tools.execute({ 31 tool: 'find_available_slots', 32 parameters: { 33 attendees, 34 duration, 35 preferred_times: preferred_times || [] 36 } 37 }); 38 39 if (availableSlots.length === 0) { 40 throw new context.errors.BusinessLogicError('No available time slots found'); 41 } 42 43 // Schedule the meeting at the first available slot 44 const selectedSlot = availableSlots[0]; 45 const event = await context.tools.execute({ 46 tool: 'create_event', 47 parameters: { 48 title: meeting_title, 49 description: meeting_description, 50 start_time: selectedSlot.start_time, 51 end_time: selectedSlot.end_time, 52 attendees 53 } 54 }); 55 56 return { 57 event_id: event.event_id, 58 scheduled_time: selectedSlot.start_time, 59 attendees_notified: attendees.length 60 }; 61 } 62 }; ``` ## Versioning and deployment [Section titled “Versioning and deployment”](#versioning-and-deployment) ### Version management [Section titled “Version management”](#version-management) Version your custom tools for backward compatibility: ```javascript 1 const toolV2 = { 2 ...originalTool, 3 version: '2.0.0', 4 // Updated implementation 5 }; 6 7 // Deploy new version 8 await agentConnect.tools.register(toolV2); 9 10 // Deprecate old version 11 await agentConnect.tools.deprecate(originalTool.name, '1.0.0'); ``` ### Deployment strategies [Section titled “Deployment strategies”](#deployment-strategies) * **Blue-green deployment**: Deploy new version alongside old version * **Canary deployment**: Gradually roll out to subset of users * **Feature flags**: Use feature flags to control tool availability * **Rollback strategy**: Plan for quick rollback if issues arise Custom tools unlock the full potential of Agent Auth by allowing you to create specialized workflows that perfectly match your business needs. With proper design, testing, and deployment practices, you can build powerful tools that enhance your team’s productivity and streamline complex operations. --- # DOCUMENT BOUNDARY --- # Scalekit optimized built-in tools > Call Scalekit's pre-built tools across 200+ connectors. Each tool returns structured, LLM-ready output with no endpoint URLs, auth headers, or parsing needed. Scalekit ships pre-built tools for every connector in the catalog: GitHub, Gmail, Slack, Salesforce, Notion, Linear, HubSpot, and more. Each tool has an LLM-ready schema and returns structured output. Your agent passes inputs; Scalekit injects the user’s credentials and handles the API call. This page assumes you have an `ACTIVE` connected account for the user. If not, see [Authorize a user](/agentkit/tools/authorize/). ## Get available tools for a user [Section titled “Get available tools for a user”](#get-available-tools-for-a-user) Use `list_scoped_tools` / `listScopedTools` to get the tools this specific user is authorized to call. **This is the list you pass to your LLM.** * Python ```python 1 from google.protobuf.json_format import MessageToDict 2 3 scoped_response, _ = actions.tools.list_scoped_tools( 4 identifier="user_123", 5 filter={"connection_names": ["github-connect"]}, # optional; omit for all connectors 6 page_size=100, # fetch beyond the default page 7 ) 8 for scoped_tool in scoped_response.tools: 9 definition = MessageToDict(scoped_tool.tool).get("definition", {}) 10 print(definition.get("name")) 11 print(definition.get("input_schema")) # JSON Schema; pass directly to your LLM ``` * Node.js ```typescript 1 const { tools } = await scalekit.tools.listScopedTools('user_123', { 2 filter: { connectionNames: ['github-connect'] }, // use filter: {} to list every connector 3 pageSize: 100, // fetch beyond the default page 4 }); 5 for (const tool of tools) { 6 const { name, input_schema } = tool.tool.definition; 7 console.log(name, input_schema); // JSON Schema; pass directly to your LLM 8 } ``` To explore tools interactively, use the playground at [**Scalekit Dashboard**](https://app.scalekit.com) **> AgentKit > Playground**. ## Execute a tool [Section titled “Execute a tool”](#execute-a-tool) Use `execute_tool` / `executeTool` to run a named tool for a specific user. Scalekit identifies the connected account with: * User identifier (`identifier`) + Connection name as shown in the Scalekit Dashboard (`connection_name`), or * Connected Account ID (`connected_account_id`) — autogenerated by Scalekit and visible in the Scalekit Dashboard - Python ```python 1 # connected account is selected using the user identifier and the connection name 2 result = actions.execute_tool( 3 tool_name="github_user_repos_list", 4 identifier="user_123", 5 connection_name="github-connect", 6 tool_input={"per_page": 5, "sort": "updated"}, 7 ) 8 print(result.data) 9 10 # alternatively, use the connected account ID 11 # result = actions.execute_tool( 12 # tool_name="github_user_repos_list", 13 # connected_account_id="ca_xxxxxx", 14 # tool_input={"per_page": 5, "sort": "updated"}, 15 # ) ``` - Node.js ```typescript 1 // connected account is selected using the user identifier and the connector 2 const result = await scalekit.actions.executeTool({ 3 toolName: 'github_user_repos_list', 4 identifier: 'user_123', 5 connector: 'github-connect', 6 toolInput: { per_page: 5, sort: 'updated' }, 7 }); 8 console.log(result.data); 9 10 // alternatively, use the connected account ID 11 // const result = await scalekit.actions.executeTool({ 12 // toolName: 'github_user_repos_list', 13 // connectedAccountId: 'ca_xxxxxx', 14 // toolInput: { per_page: 5, sort: 'updated' }, 15 // }); ``` ## Understand tool response shape [Section titled “Understand tool response shape”](#understand-tool-response-shape) `execute_tool` / `executeTool` returns a **wrapper object**, not the provider payload directly. Tool output lives under `response.data` (Python) or `result.data` (Node.js). Keys inside `data` depend on the tool you called. When you integrate a new tool, log the full wrapper once, then read fields from `data`: * Python List Google Calendar events (Python) ```python 1 response = actions.execute_tool( 2 tool_name="googlecalendar_list_events", 3 identifier="user_123", 4 connection_name="googlecalendar", 5 tool_input={"max_results": 10}, 6 ) 7 8 # Security: Log only in development; production logs may expose user data. 9 print(response.data) 10 11 events = response.data.get("events", []) 12 next_page_token = response.data.get("next_page_token") 13 print(f"Found {len(events)} events") ``` * Node.js List Google Calendar events (Node.js) ```typescript 1 const result = await scalekit.actions.executeTool({ 2 toolName: 'googlecalendar_list_events', 3 identifier: 'user_123', 4 connector: 'googlecalendar', 5 toolInput: { max_results: 10 }, 6 }); 7 8 // Security: Log only in development; production logs may expose user data. 9 console.log(result.data); 10 11 const events = (result.data as { events?: unknown[] }).events ?? []; 12 const nextPageToken = (result.data as { next_page_token?: string }).next_page_token; 13 console.log(`Found ${events.length} events`); ``` Do not treat the wrapper as the tool payload A common integration mistake is parsing `response` as if it were a flat list of events. Always read `response.data` first, then extract tool-specific keys such as `events` and `next_page_token`. ## Wire into your LLM [Section titled “Wire into your LLM”](#wire-into-your-llm) The full agent loop: fetch scoped tools → pass to LLM → execute tool calls → feed results back. * Python ```python 1 import anthropic 2 from google.protobuf.json_format import MessageToDict 3 4 client = anthropic.Anthropic() 5 6 # 1. Fetch tools scoped to this user 7 scoped_response, _ = actions.tools.list_scoped_tools( 8 identifier="user_123", 9 filter={"connection_names": ["github-connect"]}, 10 page_size=100, # fetch beyond the default page so no connector tools are missed 11 ) 12 llm_tools = [ 13 { 14 "name": MessageToDict(t.tool).get("definition", {}).get("name"), 15 "description": MessageToDict(t.tool).get("definition", {}).get("description"), 16 "input_schema": MessageToDict(t.tool).get("definition", {}).get("input_schema", {}), 17 } 18 for t in scoped_response.tools 19 ] 20 21 # 2. Send to LLM 22 messages = [{"role": "user", "content": "Summarize my 5 most recently updated repositories"}] 23 response = client.messages.create( 24 model="claude-sonnet-4-6", 25 max_tokens=1024, 26 tools=llm_tools, 27 messages=messages, 28 ) 29 30 # 3. Execute tool calls and feed results back 31 for block in response.content: 32 if block.type == "tool_use": 33 tool_result = actions.execute_tool( 34 tool_name=block.name, 35 identifier="user_123", 36 tool_input=block.input, 37 ) 38 messages.append({"role": "assistant", "content": response.content}) 39 messages.append({ 40 "role": "user", 41 "content": [{"type": "tool_result", "tool_use_id": block.id, "content": str(tool_result.data)}], 42 }) ``` * Node.js ```typescript 1 import Anthropic from '@anthropic-ai/sdk'; 2 3 const anthropic = new Anthropic(); 4 5 // 1. Fetch tools scoped to this user 6 const { tools } = await scalekit.tools.listScopedTools('user_123', { 7 filter: { connectionNames: ['github-connect'] }, 8 pageSize: 100, // fetch beyond the default page so no connector tools are missed 9 }); 10 const llmTools = tools.map((t) => ({ 11 name: t.tool.definition.name, 12 description: t.tool.definition.description, 13 input_schema: t.tool.definition.input_schema, 14 })); 15 16 // 2. Send to LLM 17 const messages: Anthropic.MessageParam[] = [ 18 { role: 'user', content: 'Summarize my 5 most recently updated repositories' }, 19 ]; 20 const response = await anthropic.messages.create({ 21 model: 'claude-sonnet-4-6', 22 max_tokens: 1024, 23 tools: llmTools, 24 messages, 25 }); 26 27 // 3. Execute tool calls and feed results back 28 for (const block of response.content) { 29 if (block.type === 'tool_use') { 30 const toolResult = await scalekit.actions.executeTool({ 31 toolName: block.name, 32 identifier: 'user_123', 33 toolInput: block.input as Record, 34 }); 35 messages.push({ role: 'assistant', content: response.content }); 36 messages.push({ 37 role: 'user', 38 content: [{ type: 'tool_result', tool_use_id: block.id, content: JSON.stringify(toolResult.data) }], 39 }); 40 } 41 } ``` ## Use a framework adapter [Section titled “Use a framework adapter”](#use-a-framework-adapter) For LangChain and Google ADK, Scalekit returns native tool objects in Python with no schema reshaping needed. * LangChain ```python 1 from langchain_openai import ChatOpenAI 2 from langchain.agents import create_agent 3 4 tools = actions.langchain.get_tools( 5 identifier="user_123", 6 connection_names=["github-connect"], 7 page_size=100, # avoid missing tools when a connector has more than the default page 8 ) 9 llm = ChatOpenAI(model="claude-sonnet-4-6") 10 agent = create_agent(model=llm, tools=tools, system_prompt="You are a helpful assistant.") 11 result = agent.invoke({"messages": [{"role": "user", "content": "List my 5 most recently updated repositories"}]}) ``` * Google ADK ```python 1 from google.adk.agents import Agent 2 from google.adk.models.lite_llm import LiteLlm 3 4 github_tools = actions.google.get_tools( 5 identifier="user_123", 6 connection_names=["github-connect"], 7 page_size=100, # avoid missing tools when a connector has more than the default page 8 ) 9 agent = Agent( 10 name="github_assistant", 11 model=LiteLlm(model="claude-sonnet-4-6"), 12 tools=github_tools, 13 ) ``` * Node.js (Vercel AI SDK) ```typescript 1 import { generateText, jsonSchema, tool } from 'ai'; 2 3 const { tools: scopedTools } = await scalekit.tools.listScopedTools('user_123', { 4 filter: { connectionNames: ['github-connect'] }, 5 pageSize: 100, // fetch beyond the default page so no connector tools are missed 6 }); 7 const tools = Object.fromEntries( 8 scopedTools.map((t) => [ 9 t.tool.definition.name, 10 tool({ 11 description: t.tool.definition.description, 12 parameters: jsonSchema(t.tool.definition.input_schema ?? { type: 'object', properties: {} }), 13 execute: async (args) => { 14 const result = await scalekit.actions.executeTool({ 15 toolName: t.tool.definition.name, 16 toolInput: args, 17 identifier: 'user_123', 18 }); 19 return result.data; 20 }, 21 }), 22 ]), 23 ); ``` ## Troubleshooting [Section titled “Troubleshooting”](#troubleshooting) If you need an endpoint not covered by optimized tools, see [Custom tools](/agentkit/tools/custom-tools/). --- # DOCUMENT BOUNDARY --- # Verify user identity > Confirm that the user who completed the OAuth consent is the same user your app intended to connect. User verification applies to OAuth-based connectors only. For API key, basic auth, and key pair connectors, the user provides credentials directly. No OAuth flow, no verification step needed. For OAuth connectors, before activating a connected account, Scalekit confirms that the user who completed the OAuth consent is the same user your app intended to connect. This **user verification** step runs every time a connected account is authorized and prevents OAuth consent from activating on the wrong account. Choose a mode in **AgentKit** > **User Verification**: * **Custom user verification**: Your server confirms the authorizing user matches the user your app intended to connect. Use in production. Without this, any user who receives an authorization link can activate a connected account (including the wrong one). * **Scalekit users only**: Scalekit checks that the authorizing user is signed in to your Scalekit dashboard. No code required. Use during development and internal testing when all users are already on your team. ![AgentKit User Verification showing Custom user verifier and Scalekit users only](/.netlify/images?url=_astro%2Fuser-verification-config.R9EpQz_E.png\&w=2224\&h=1590\&dpl=6a7afd35ca95e20008d421ee) Your application implements the verify step. End users never interact with Scalekit directly. When the user finishes OAuth, Scalekit redirects to your verify URL with `auth_request_id` and `state` params. Your route reads the user from your session, calls Scalekit’s verify API with the `auth_request_id` and the original `identifier`, and if they match, the connected account activates. ## Implement verification in your app [Section titled “Implement verification in your app”](#implement-verification-in-your-app) If you haven’t installed the SDK yet, see the [quickstart](/agentkit/quickstart/). ### Generate the authorization link [Section titled “Generate the authorization link”](#generate-the-authorization-link) Pass these fields when creating the authorization link: | Field | Description | | ----------------- | ------------------------------------------------------------------------------------------------- | | `identifier` | **Required.** Your user’s ID or email. Scalekit stores this and checks it matches at verify time. | | `user_verify_url` | **Required.** Your callback URL; Scalekit redirects the user here after OAuth completes. | | `state` | **Recommended.** A random value to prevent CSRF. | * Python ```python 1 import secrets 2 3 # Generate a state value to prevent CSRF 4 state = secrets.token_urlsafe(32) 5 # Store state in a secure, HTTP-only cookie to validate on callback 6 7 response = scalekit_client.actions.get_authorization_link( 8 connection_name=connector, 9 identifier=user_id, 10 user_verify_url="https://app.yourapp.com/user/verify", 11 state=state, 12 ) ``` * Node.js ```typescript 1 import crypto from 'node:crypto'; 2 3 // Generate a state value to prevent CSRF 4 const state = crypto.randomUUID(); 5 // Store state in a secure, HTTP-only cookie to validate on callback 6 7 const { link } = await scalekit.actions.getAuthorizationLink({ 8 identifier: userId, 9 connectionName: connector, 10 userVerifyUrl: 'https://app.yourapp.com/user/verify', 11 state, 12 }); ``` ### Handle the verification callback [Section titled “Handle the verification callback”](#handle-the-verification-callback) After OAuth completes, Scalekit redirects to your `user_verify_url`: ```http 1 GET https://app.yourapp.com/user/verify?auth_request_id=req_xyz&state= ``` Validate `state` against your cookie, then call Scalekit’s verify endpoint server-side. Never trust query params for identity Read the user’s identity from your own session, not from the URL. Use `state` for session correlation only. * Python ```python 1 # 1. Validate state from query param matches state in cookie 2 # 2. Read user identity from your session, not from the URL 3 4 response = scalekit_client.actions.verify_connected_account_user( 5 auth_request_id=auth_request_id, 6 identifier=user_id, # must match what was stored at link creation 7 ) 8 # On success: redirect to response.post_user_verify_redirect_url ``` * Node.js ```typescript 1 // 1. Validate state from query param matches state in cookie 2 // 2. Read user identity from your session, not from the URL 3 4 const { postUserVerifyRedirectUrl } = 5 await scalekit.actions.verifyConnectedAccountUser({ 6 authRequestId: auth_request_id, 7 identifier: userId, // must match what was stored at link creation 8 }); 9 // On success: redirect to postUserVerifyRedirectUrl ``` On success, the connected account is activated. Redirect the user using `post_user_verify_redirect_url`. ## Common scenarios [Section titled “Common scenarios”](#common-scenarios) --- # DOCUMENT BOUNDARY --- # Claude Integration > Integrate Scalekit with Claude for AI-powered authentication workflows Coming soon --- # DOCUMENT BOUNDARY --- # Codex Integration > Use Scalekit with Codex for automated authentication code generation Coming soon --- # DOCUMENT BOUNDARY --- # Use Scalekit docs in your AI coding agent > Use Context7 to give your AI coding agent accurate, up-to-date Scalekit documentation so it can help you integrate faster and with fewer errors. AI coding agents like Claude Code and Cursor work from training data that can be months out of date. When you ask them to help integrate Scalekit, they may reference old APIs, deprecated patterns, or incorrect parameter names — leading to bugs that are hard to trace. [Context7](https://context7.com) provides two ways to access live, version-accurate documentation: * **CLI** — query docs directly from your terminal (recommended for most developers) * **MCP server** — integrates with AI agents for automatic doc injection Both methods pull the same up-to-date content. Choose CLI for direct control, or MCP server for seamless AI agent integration. Scalekit’s full developer documentation is indexed on Context7 at [context7.com/scalekit-inc/developer-docs](https://context7.com/scalekit-inc/developer-docs), covering hundreds of pages and thousands of code snippets across SSO, SCIM, MCP auth, agent auth, and connected accounts. ## Get accurate answers about Scalekit [Section titled “Get accurate answers about Scalekit”](#get-accurate-answers-about-scalekit) Context7 retrieves relevant documentation from the indexed Scalekit docs and delivers it to you or your agent. The AI then answers using accurate, current content rather than training data. Context7 provides three main capabilities: * `library` — resolve library IDs and discover docs * `docs` — fetch specific documentation sections * MCP server tools for AI agent integration 1. #### Set up Context7 [Section titled “Set up Context7”](#set-up-context7) Context7 can be set up via CLI or as an MCP server. Choose your method: * CLI Install the Context7 CLI to query docs directly from your terminal. **One-off installation via npx:** ```sh npx ctx7 --help ``` **Global installation:** ```sh npm install -g ctx7 ctx7 --version ``` Requires Node.js 18 or higher. The CLI provides three main capabilities: * **Fetch docs** — query specific documentation sections * **Manage skills** — generate AI agent skills for auto-invocation * **Configure MCP** — set up MCP server integration * MCP Server Context7 is configured as an MCP server in your coding agent. You can also add it directly from [context7.com](https://context7.com). Choose your tool: * Claude Code Run one of the following commands in your terminal: **Local (stdio):** ```sh claude mcp add --scope user context7 -- npx -y @upstash/context7-mcp ``` **Remote (HTTP):** ```sh claude mcp add --scope user --transport http context7 https://mcp.context7.com/mcp ``` To verify the server was added: ```sh claude mcp list ``` * Cursor 1. Open **Settings > Cursor Settings > MCP** and click **Add New Global MCP Server**. Paste one of the following configs: **Remote server:** ```json { "mcpServers": { "context7": { "url": "https://mcp.context7.com/mcp" } } } ``` **Local server:** ```json { "mcpServers": { "context7": { "command": "npx", "args": ["-y", "@upstash/context7-mcp"] } } } ``` 2. Restart Cursor. * Claude Desktop The easiest way is to install Context7 directly from the Claude Desktop interface: 1. Open Claude Desktop and go to **Customize > Connectors**. 2. Search for **Context7** and click **Install**. Alternatively, configure it manually via **Settings > Developer > Edit Config** and add to `claude_desktop_config.json`: ```json { "mcpServers": { "context7": { "command": "npx", "args": ["-y", "@upstash/context7-mcp"] } } } ``` Restart Claude Desktop after saving. * Windsurf 1. Open **Settings > Developer > Edit Config** and open `windsurf_config.json`. 2. Add the following config and save: ```json { "mcpServers": { "context7": { "command": "npx", "args": ["-y", "@upstash/context7-mcp"] } } } ``` 3. Restart Windsurf. * Claude Code Run one of the following commands in your terminal: **Local (stdio):** ```sh claude mcp add --scope user context7 -- npx -y @upstash/context7-mcp ``` **Remote (HTTP):** ```sh claude mcp add --scope user --transport http context7 https://mcp.context7.com/mcp ``` To verify the server was added: ```sh claude mcp list ``` * Cursor 1. Open **Settings > Cursor Settings > MCP** and click **Add New Global MCP Server**. Paste one of the following configs: **Remote server:** ```json { "mcpServers": { "context7": { "url": "https://mcp.context7.com/mcp" } } } ``` **Local server:** ```json { "mcpServers": { "context7": { "command": "npx", "args": ["-y", "@upstash/context7-mcp"] } } } ``` 2. Restart Cursor. * Claude Desktop The easiest way is to install Context7 directly from the Claude Desktop interface: 1. Open Claude Desktop and go to **Customize > Connectors**. 2. Search for **Context7** and click **Install**. Alternatively, configure it manually via **Settings > Developer > Edit Config** and add to `claude_desktop_config.json`: ```json { "mcpServers": { "context7": { "command": "npx", "args": ["-y", "@upstash/context7-mcp"] } } } ``` Restart Claude Desktop after saving. * Windsurf 1. Open **Settings > Developer > Edit Config** and open `windsurf_config.json`. 2. Add the following config and save: ```json { "mcpServers": { "context7": { "command": "npx", "args": ["-y", "@upstash/context7-mcp"] } } } ``` 3. Restart Windsurf. 2. #### Query Scalekit docs [Section titled “Query Scalekit docs”](#query-scalekit-docs) * Using CLI Querying Scalekit docs via CLI is a two-step process. **Step 1 — Resolve Scalekit library:** ```sh ctx7 library scalekit "How to set up SSO" ctx7 library scalekit "SCIM user provisioning" ctx7 library scalekit "MCP authentication setup" ``` Expected result for library selection: | Field | Description | | ----------------- | ----------------------------------- | | Library ID | `/scalekit-inc/developer-docs` | | Code Snippets | High (hundreds of indexed examples) | | Source Reputation | High | | Benchmark Score | Quality score from 0 to 100 | **Step 2 — Fetch Scalekit docs:** ```sh # SSO queries ctx7 docs /scalekit-inc/developer-docs "How to set up SSO with Scalekit" ctx7 docs /scalekit-inc/developer-docs "Configure SAML for enterprise SSO" # SCIM queries ctx7 docs /scalekit-inc/developer-docs "How to provision users with SCIM" ctx7 docs /scalekit-inc/developer-docs "Set up SCIM for Active Directory" # MCP auth queries ctx7 docs /scalekit-inc/developer-docs "Add MCP auth to my server" ctx7 docs /scalekit-inc/developer-docs "Configure agent authentication" # Connected accounts queries ctx7 docs /scalekit-inc/developer-docs "Configure connected accounts for GitHub OAuth" ctx7 docs /scalekit-inc/developer-docs "Set up Google OAuth integration" # JSON output for scripting ctx7 docs /scalekit-inc/developer-docs "SSO setup" --json # Pipe to other tools ctx7 docs /scalekit-inc/developer-docs "SCIM provisioning" | head -50 ``` * Using MCP Server Once Context7 is running, add **`use context7`** to any prompt where you want current Scalekit documentation injected automatically. **General Scalekit queries:** ```txt How do I set up SSO with Scalekit? use context7 ``` ```txt Show me how to provision users with SCIM using Scalekit. use context7 ``` **Target Scalekit docs directly** using the library path: ```txt use library /scalekit-inc/developer-docs for how to add MCP auth to my server ``` **Combine with version or feature specificity:** ```txt How do I configure connected accounts for GitHub OAuth with Scalekit? use context7 ``` 3. #### Auto-invoke Context7 (optional) [Section titled “Auto-invoke Context7 (optional)”](#auto-invoke-context7-optional) Configure your coding agent to always use Context7 for library and API questions — no need to add “use context7” manually each time. * CLI Use `ctx7 setup --cli` to configure Context7 for AI coding agents. This installs a `docs` skill that guides the agent to use `ctx7 library` and `ctx7 docs` commands for Scalekit documentation. **Setup commands:** ```sh # Interactive setup (prompts for agent) ctx7 setup --cli # Direct setup for specific agents ctx7 setup --cli --claude # Claude Code (~/.claude/skills) ctx7 setup --cli --cursor # Cursor (~/.cursor/skills) ctx7 setup --cli --universal # Universal (~/.config/agents/skills) # Project-specific setup (default is global) ctx7 setup --cli --project # Skip confirmation prompts ctx7 setup --cli --yes ``` **What gets installed — CLI + Skills mode:** | File | Purpose | | ---------------------- | --------------------------------------------------------------------- | | Agent skills directory | `docs` skill — guides the agent to use `ctx7 library` and `ctx7 docs` | When the `docs` skill is installed, your AI agent will automatically use `ctx7` commands to fetch accurate Scalekit documentation when asked about SSO, SCIM, MCP auth, or other Scalekit features. * MCP Server Configure your coding agent to always use Context7 for library and API questions — no need to add “use context7” manually each time. * Claude Code Add the following rule to your project’s `CLAUDE.md` file: ```md Always use Context7 MCP when I need library or API documentation, code generation, or setup and configuration steps. ``` This applies project-wide. For a global rule, add it to `~/.claude/CLAUDE.md`. * Cursor Open **Settings > Cursor Settings > Rules** and add: ```txt Always use Context7 MCP when I need library or API documentation, code generation, or setup and configuration steps. ``` * Claude Code Add the following rule to your project’s `CLAUDE.md` file: ```md Always use Context7 MCP when I need library or API documentation, code generation, or setup and configuration steps. ``` This applies project-wide. For a global rule, add it to `~/.claude/CLAUDE.md`. * Cursor Open **Settings > Cursor Settings > Rules** and add: ```txt Always use Context7 MCP when I need library or API documentation, code generation, or setup and configuration steps. ``` 4. #### Increase rate limits with an API key [Section titled “Increase rate limits with an API key”](#increase-rate-limits-with-an-api-key) The free tier of Context7 has rate limits. For heavier usage or team environments, get a free API key from [context7.com/dashboard](https://context7.com/dashboard) and add it to your configuration. * MCP Server * Claude Code **Local:** ```sh claude mcp add --scope user context7 -- npx -y @upstash/context7-mcp --api-key YOUR_API_KEY ``` **Remote:** ```sh claude mcp add --scope user --header "CONTEXT7_API_KEY: YOUR_API_KEY" --transport http context7 https://mcp.context7.com/mcp ``` * Cursor **Remote server with API key:** ```json { "mcpServers": { "context7": { "url": "https://mcp.context7.com/mcp", "headers": { "CONTEXT7_API_KEY": "YOUR_API_KEY" } } } } ``` **Local server with API key:** ```json { "mcpServers": { "context7": { "command": "npx", "args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"] } } } ``` * Claude Desktop / Windsurf ```json { "mcpServers": { "context7": { "command": "npx", "args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"] } } } ``` * CLI **Local:** ```sh claude mcp add --scope user context7 -- npx -y @upstash/context7-mcp --api-key YOUR_API_KEY ``` **Remote:** ```sh claude mcp add --scope user --header "CONTEXT7_API_KEY: YOUR_API_KEY" --transport http context7 https://mcp.context7.com/mcp ``` * Claude Code **Remote server with API key:** ```json { "mcpServers": { "context7": { "url": "https://mcp.context7.com/mcp", "headers": { "CONTEXT7_API_KEY": "YOUR_API_KEY" } } } } ``` **Local server with API key:** ```json { "mcpServers": { "context7": { "command": "npx", "args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"] } } } ``` * Cursor ```json { "mcpServers": { "context7": { "command": "npx", "args": ["-y", "@upstash/context7-mcp", "--api-key", "YOUR_API_KEY"] } } } ``` * Claude Desktop / Windsurf Set an API key via environment variable for higher rate limits: ```sh # Set API key for current session export CONTEXT7_API_KEY=your_key # Add to ~/.bashrc or ~/.zshrc for permanent use echo 'export CONTEXT7_API_KEY=your_key' >> ~/.bashrc ``` API keys start with `ctx7sk`. If authentication fails with a 401 error, verify the key format matches your method (HTTP header for MCP, environment variable for CLI). --- # DOCUMENT BOUNDARY --- # Cursor Integration > Use Scalekit with Cursor via the local installer while the marketplace listing is under review Use Scalekit with Cursor by running the local installer, enabling the auth plugin you need, and then prompting Cursor to generate the implementation in your existing codebase. 1. ## Install the authstack plugin (recommended) Terminal ```bash npx @scalekit-inc/cli setup ``` For repeated use, install globally: Terminal ```bash npm install -g @scalekit-inc/cli scalekit setup ``` The CLI detects Cursor and installs the authstack plugin directly. 2. ## Reload and select plugins Restart Cursor (or run **Developer: Reload Window**), then open **Settings > Cursor Settings > Plugins**. Enable the Scalekit plugins you need (AgentKit, SaaSKit, etc.). 3. ## Generate the implementation Open Cursor’s chat panel with **Cmd+L** (macOS) or **Ctrl+L** (Windows/Linux) and paste in an implementation prompt from the feature page (or describe what you need in natural language). The installed Scalekit plugins provide the agent with accurate patterns. Review generated code Always review AI-generated authentication code before deployment. Verify that environment variables, token validation logic, and error handling match your application’s security requirements. 4. ## Verify the implementation After Cursor finishes generating code, confirm all authentication components are in place: * The Scalekit plugin appears in **Settings > Cursor Settings > Plugins** * Scalekit client initialized with your API credentials (set up a `.env` file with your Scalekit environment variables) * Authorization URL generation and callback handler * Session or token integration matching your application’s existing patterns --- # DOCUMENT BOUNDARY --- # Scalekit MCP Server > Learn how to use the Scalekit MCP Server to manage your users, organizations, and applications. Scalekit Model Context Protocol (MCP) server provides comprehensive tools for managing environments, organizations, users, connections, and workspace operations. Built for developers who want to connect their AI tools to Scalekit context and capabilities based on simple natural language queries. This MCP server enables AI assistants to interact with Scalekit’s identity and access management platform through a standardized set of tools. It provides secure, OAuth-protected access to manage environments, organizations, users, authentication connections, and more. * Environment management and configuration * Organization and user management * Workspace member administration * OIDC connection setup and management * MCP server registration and configuration * Role and scope management * Admin portal link generation ## Configuration [Section titled “Configuration”](#configuration) Connect the Scalekit MCP server to your AI coding tool. Find your tool below and follow the steps — your client will prompt you to sign in via OAuth on first use. ### Claude Code [Section titled “Claude Code”](#claude-code) Run this command in your terminal: ```bash 1 claude mcp add --transport http scalekit https://mcp.scalekit.com/ ``` ### Claude Desktop [Section titled “Claude Desktop”](#claude-desktop) 1. Open Claude Desktop 2. Go to **Settings → Connectors** 3. Click **Add custom connector** 4. Enter `Scalekit` as the name and `https://mcp.scalekit.com` as the URL 5. Click **Connect** to authenticate ### VS Code [Section titled “VS Code”](#vs-code) Edit `.vscode/mcp.json` in your project (requires VS Code 1.101 or later): ```json 1 { 2 "servers": { 3 "scalekit": { 4 "type": "http", 5 "url": "https://mcp.scalekit.com/" 6 } 7 } 8 } ``` ### Cursor [Section titled “Cursor”](#cursor) Edit `~/.cursor/mcp.json`, or open **Cursor Settings → MCP → Add New Global MCP Server** and paste the config: ```json 1 { 2 "mcpServers": { 3 "scalekit": { 4 "url": "https://mcp.scalekit.com/" 5 } 6 } 7 } ``` ### Windsurf [Section titled “Windsurf”](#windsurf) Edit `~/.codeium/windsurf/mcp_config.json`: ```json 1 { 2 "mcpServers": { 3 "scalekit": { 4 "serverUrl": "https://mcp.scalekit.com/" 5 } 6 } 7 } ``` ### Gemini CLI [Section titled “Gemini CLI”](#gemini-cli) Edit `~/.gemini/settings.json`: ```json 1 { 2 "mcpServers": { 3 "scalekit": { 4 "httpUrl": "https://mcp.scalekit.com/" 5 } 6 } 7 } ``` ### Codex [Section titled “Codex”](#codex) Run this command in your terminal: ```bash 1 codex mcp add scalekit --url https://mcp.scalekit.com/ ``` ### OpenCode [Section titled “OpenCode”](#opencode) Edit `opencode.json` in your project root: ```json 1 { 2 "mcp": { 3 "scalekit": { 4 "type": "remote", 5 "url": "https://mcp.scalekit.com/", 6 "enabled": true 7 } 8 } 9 } ``` ### Roo Code [Section titled “Roo Code”](#roo-code) Add to your MCP configuration: ```json 1 { 2 "mcpServers": { 3 "scalekit": { 4 "type": "streamable-http", 5 "url": "https://mcp.scalekit.com/" 6 } 7 } 8 } ``` ### Zed [Section titled “Zed”](#zed) Add to your Zed `settings.json`: ```json 1 { 2 "context_servers": { 3 "scalekit": { 4 "url": "https://mcp.scalekit.com/" 5 } 6 } 7 } ``` ### Kiro [Section titled “Kiro”](#kiro) Edit `~/.kiro/settings/mcp.json`: ```json 1 { 2 "mcpServers": { 3 "scalekit": { 4 "url": "https://mcp.scalekit.com/" 5 } 6 } 7 } ``` ### Warp [Section titled “Warp”](#warp) Go to **Settings → MCP Servers → Add MCP Server** and enter `https://mcp.scalekit.com/`, or add to your Warp MCP config: ```json 1 { 2 "scalekit": { 3 "serverUrl": "https://mcp.scalekit.com/" 4 } 5 } ``` ### v0 by Vercel [Section titled “v0 by Vercel”](#v0-by-vercel) Go to **Prompt Tools → Add MCP** and enter `https://mcp.scalekit.com/`. ## GitHub [Section titled “GitHub”](#github) The source code for the Scalekit MCP server is available on [GitHub](https://github.com/scalekit-inc/mcp), including a full list of available tools and their descriptions. * Open an issue if you find a bug or have a question. * Submit a PR or open an issue to suggest new tools. --- # DOCUMENT BOUNDARY --- # VS Code Extension > Enhance your development workflow with the Scalekit VS Code extension Coming soon --- # DOCUMENT BOUNDARY --- # Agent connectors > Search connectors and tools for Slack, Google Workspace, Salesforce, and more. Search connectors and tools by name, category, or capability. Use this page to find a provider, open its docs, and see which tools your agents can call. Search connectors or tools… All categories (all)All auth types (all) ## Connectors [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/customsmartfhir.png)](/agentkit/connectors/customsmartfhir/) [SMART App on FHIR connector](/agentkit/connectors/customsmartfhir/) [SMART App on FHIR is a healthcare interoperability provider that enables secure access to electronic health records and clinical data using the SMART on...](/agentkit/connectors/customsmartfhir/) [SMART On FHIR](/agentkit/connectors/customsmartfhir/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/activepieces.svg)](/agentkit/connectors/activepiecesmcp/) [Activepieces MCP connector](/agentkit/connectors/activepiecesmcp/) [Connect to Activepieces MCP to trigger and manage no-code automation flows directly from your AI workflows.](/agentkit/connectors/activepiecesmcp/) [OAuth2.1/DCR](/agentkit/connectors/activepiecesmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/adobe.svg)](/agentkit/connectors/adobemarketingagentmcp/) [Adobe Marketing Agent MCP connector](/agentkit/connectors/adobemarketingagentmcp/) [Connect to Adobe Marketing Cloud. Manage campaigns, analytics, and journeys using a natural-language AI assistant.](/agentkit/connectors/adobemarketingagentmcp/) [OAuth 2.1/DCR](/agentkit/connectors/adobemarketingagentmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/advancedmd.png)](/agentkit/connectors/advancedmd/) [AdvancedMD connector](/agentkit/connectors/advancedmd/) [AdvancedMD is a cloud-based medical practice management and electronic health record (EHR) platform. This connector uses the SMART on FHIR authorization...](/agentkit/connectors/advancedmd/) [SMART On FHIR](/agentkit/connectors/advancedmd/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/adzviser.svg)](/agentkit/connectors/adzvisermcp/) [Adzviser MCP connector](/agentkit/connectors/adzvisermcp/) [Connect to Adzviser MCP to query real-time marketing analytics across 46+ platforms - Google Ads, Facebook Ads, GA4, TikTok, LinkedIn, and more - from a...](/agentkit/connectors/adzvisermcp/) [OAuth 2.1/DCR](/agentkit/connectors/adzvisermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/affinda.svg)](/agentkit/connectors/affindamcp/) [Affinda MCP connector](/agentkit/connectors/affindamcp/) [AI-powered document processing platform that extracts, validates, and integrates structured data from invoices, resumes, contracts, and custom document...](/agentkit/connectors/affindamcp/) [OAuth2.1/DCR](/agentkit/connectors/affindamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/affinity.svg)](/agentkit/connectors/affinity/) [Affinity connector](/agentkit/connectors/affinity/) [Connect to Affinity relationship intelligence CRM to manage deal flow, relationships, pipeline opportunities, and network connections for private capital...](/agentkit/connectors/affinity/) [Bearer Token](/agentkit/connectors/affinity/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/agencyanalytics.svg)](/agentkit/connectors/agencyanalyticsmcp/) [Agency Analytics MCP connector](/agentkit/connectors/agencyanalyticsmcp/) [Agency Analytics is a marketing reporting platform that enables digital agencies to monitor SEO, PPC, social media, and other channel performance in...](/agentkit/connectors/agencyanalyticsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/agencyanalyticsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/agentmail.svg)](/agentkit/connectors/agentmailmcp/) [Agentmail MCP connector](/agentkit/connectors/agentmailmcp/) [Connect to Agentmail MCP. Manage inboxes, send and receive email, handle drafts, threads, and attachments from your AI workflows.](/agentkit/connectors/agentmailmcp/) [OAuth 2.1/DCR](/agentkit/connectors/agentmailmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/ahrefs.svg)](/agentkit/connectors/ahrefsmcp/) [Ahrefs MCP connector](/agentkit/connectors/ahrefsmcp/) [Connect to Ahrefs MCP to access SEO data including backlinks, keyword research, site audits, rank tracking, and web analytics directly from your AI...](/agentkit/connectors/ahrefsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/ahrefsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airbyte.svg)](/agentkit/connectors/airbytemcp/) [Airbyte MCP connector](/agentkit/connectors/airbytemcp/) [Connect to Airbyte's MCP server to manage data pipelines, sources, destinations, and connections for your data integration workflows.](/agentkit/connectors/airbytemcp/) [OAuth2.1/DCR](/agentkit/connectors/airbytemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airops.svg)](/agentkit/connectors/airopsmcp/) [Airops MCP connector](/agentkit/connectors/airopsmcp/) [Connect to AirOps MCP. Manage brand kits, run AI-powered analytics, track AEO citations, and automate content workflows from your AI agents.](/agentkit/connectors/airopsmcp/) [API Key](/agentkit/connectors/airopsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airparser.svg)](/agentkit/connectors/airparsermcp/) [Airparser MCP connector](/agentkit/connectors/airparsermcp/) [AI-powered document parser that extracts structured data from PDFs, emails, and other documents.](/agentkit/connectors/airparsermcp/) [OAuth2.1/DCR](/agentkit/connectors/airparsermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airtable.svg)](/agentkit/connectors/airtable/) [Airtable connector](/agentkit/connectors/airtable/) [Connect to Airtable. Manage databases, tables, records, and collaborate on structured data](/agentkit/connectors/airtable/) [OAuth 2.0](/agentkit/connectors/airtable/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airtable.svg)](/agentkit/connectors/airtablemcp/) [Airtable MCP connector](/agentkit/connectors/airtablemcp/) [Connect to Airtable MCP. Manage bases, tables, records, views, fields, and automations from your AI workflows.](/agentkit/connectors/airtablemcp/) [OAuth 2.1/DCR](/agentkit/connectors/airtablemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/alphaxiv.svg)](/agentkit/connectors/alphaxivmcp/) [AlphaXiv MCP connector](/agentkit/connectors/alphaxivmcp/) [Connect to AlphaXiv MCP to search and retrieve arXiv research papers, abstracts, authors, and citations from your AI workflows.](/agentkit/connectors/alphaxivmcp/) [OAuth 2.1/DCR](/agentkit/connectors/alphaxivmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/amplitude.svg)](/agentkit/connectors/amplitudeanalytics/) [Amplitude Analytics connector](/agentkit/connectors/amplitudeanalytics/) [Connect to Amplitude's analytics REST APIs: event segmentation, funnels, cohorts, taxonomy, chart annotations, session replay, export, releases, streaming...](/agentkit/connectors/amplitudeanalytics/) [API Key + Secret Key](/agentkit/connectors/amplitudeanalytics/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/amplitude.svg)](/agentkit/connectors/amplitudeexperimentmanagement/) [Amplitude Experiment Management connector](/agentkit/connectors/amplitudeexperimentmanagement/) [Manage Amplitude Experiment feature flags, experiments, mutex groups, holdouts, and deployments. Separate connector from Experiment Evaluation (real-time...](/agentkit/connectors/amplitudeexperimentmanagement/) [Bearer Token](/agentkit/connectors/amplitudeexperimentmanagement/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/anakin.svg)](/agentkit/connectors/anakinmcp/) [Anakin MCP connector](/agentkit/connectors/anakinmcp/) [Anakin is an AI platform and marketplace that lets you build, deploy, and access a wide range of AI tools and automated workflows. This MCP connector...](/agentkit/connectors/anakinmcp/) [OAuth2.1/DCR](/agentkit/connectors/anakinmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/anchorbrowser.svg)](/agentkit/connectors/anchorbrowsermcp/) [Anchor Browser MCP connector](/agentkit/connectors/anchorbrowsermcp/) [Connect to Anchor Browser MCP to run cloud browser automation, control live browser sessions, extract web data, and let AI agents browse and act on the...](/agentkit/connectors/anchorbrowsermcp/) [OAuth 2.1/DCR](/agentkit/connectors/anchorbrowsermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/apify.svg)](/agentkit/connectors/apifymcp/) [Apify MCP connector](/agentkit/connectors/apifymcp/) [Connect to Apify MCP to run web scraping, browser automation, and data extraction Actors directly from your AI workflows.](/agentkit/connectors/apifymcp/) [Bearer Token](/agentkit/connectors/apifymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/apollo.svg)](/agentkit/connectors/apollo/) [Apollo connector](/agentkit/connectors/apollo/) [Connect to Apollo.io to search and enrich B2B contacts and accounts, manage CRM contacts, and automate outreach sequences.](/agentkit/connectors/apollo/) [OAuth 2.0](/agentkit/connectors/apollo/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/apollo.svg)](/agentkit/connectors/apollomcp/) [Apollo MCP connector](/agentkit/connectors/apollomcp/) [Connect to Apollo MCP to search B2B contacts, enrich people and organizations, manage CRM records, and enroll prospects in sequences.](/agentkit/connectors/apollomcp/) [OAuth 2.1/DCR](/agentkit/connectors/apollomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/appsignal.svg)](/agentkit/connectors/appsignalmcp/) [AppSignal MCP connector](/agentkit/connectors/appsignalmcp/) [AppSignal is an application monitoring and performance management platform providing error tracking, performance monitoring, and alerting for Ruby...](/agentkit/connectors/appsignalmcp/) [OAuth2.1/DCR](/agentkit/connectors/appsignalmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/asana-n.svg)](/agentkit/connectors/asana/) [Asana connector](/agentkit/connectors/asana/) [Connect to Asana. Manage tasks, projects, teams, and workflow automation](/agentkit/connectors/asana/) [OAuth 2.0](/agentkit/connectors/asana/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/asana-n.svg)](/agentkit/connectors/asanamcp/) [Asana MCP connector](/agentkit/connectors/asanamcp/) [Connect to Asana MCP server to manage tasks, projects, and teams directly from your AI workflows.](/agentkit/connectors/asanamcp/) [OAuth 2.1](/agentkit/connectors/asanamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/atlassian.svg)](/agentkit/connectors/atlassianmcp/) [Atlassian Rovo MCP connector](/agentkit/connectors/atlassianmcp/) [Connect to Atlassian Rovo MCP server to manage Jira issues, Confluence pages, and Compass components directly from your AI workflows.](/agentkit/connectors/atlassianmcp/) [OAuth 2.1/DCR](/agentkit/connectors/atlassianmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/attention.svg)](/agentkit/connectors/attention/) [Attention connector](/agentkit/connectors/attention/) [Connect to Attention for AI insights, conversations, teams, and workflows](/agentkit/connectors/attention/) [API Key](/agentkit/connectors/attention/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/attio.svg)](/agentkit/connectors/attio/) [Attio connector](/agentkit/connectors/attio/) [Connect to Attio CRM to manage contacts, companies, deals, notes, tasks, and lists with a modern relationship management platform.](/agentkit/connectors/attio/) [OAuth 2.0](/agentkit/connectors/attio/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/attio.svg)](/agentkit/connectors/attiomcp/) [Attio MCP connector](/agentkit/connectors/attiomcp/) [Connect to Attio MCP. Access and manage CRM records, lists, notes, tasks, emails, and workspace data across people, companies, and deals.](/agentkit/connectors/attiomcp/) [OAuth 2.1/DCR](/agentkit/connectors/attiomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/redshift.svg)](/agentkit/connectors/redshift/) [AWS Redshift connector](/agentkit/connectors/redshift/) [Connect Amazon Redshift to Scalekit with the Trusted IDP flow so agents run SQL over federated AWS credentials, with no long-lived keys stored.](/agentkit/connectors/redshift/) [Trusted IDP](/agentkit/connectors/redshift/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/axiom.svg)](/agentkit/connectors/axiommcp/) [Axiom MCP connector](/agentkit/connectors/axiommcp/) [Axiom is a cloud-native data analytics and observability platform for ingesting, storing, and querying logs, events, traces, and metrics at scale. The MCP...](/agentkit/connectors/axiommcp/) [OAuth2.1/DCR](/agentkit/connectors/axiommcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/betterstack.svg)](/agentkit/connectors/betterstackmcp/) [Betterstack MCP connector](/agentkit/connectors/betterstackmcp/) [Monitor uptime, manage logs, and respond to incidents with Better Stack's observability platform.](/agentkit/connectors/betterstackmcp/) [OAuth2.1/DCR](/agentkit/connectors/betterstackmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bigquery.svg)](/agentkit/connectors/bigqueryserviceaccount/) [BigQuery (Service Account) connector](/agentkit/connectors/bigqueryserviceaccount/) [Connect to Google BigQuery using a GCP service account for server-to-server authentication without user login.](/agentkit/connectors/bigqueryserviceaccount/) [Service Account](/agentkit/connectors/bigqueryserviceaccount/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/biorendermcp.svg)](/agentkit/connectors/biorendermcp/) [Bio Render MCP connector](/agentkit/connectors/biorendermcp/) [Connect to BioRender MCP. Search BioRender's scientific icon and figure template libraries to build publication-ready biological illustrations.](/agentkit/connectors/biorendermcp/) [OAuth 2.1/DCR](/agentkit/connectors/biorendermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/biomni.svg)](/agentkit/connectors/biomnimcp/) [Biomni MCP connector](/agentkit/connectors/biomnimcp/) [Connect to Biomni MCP by phylo.bio, an AI biomedical research assistant. Analyze life-sciences data, interpret genomic variants, query curated databases...](/agentkit/connectors/biomnimcp/) [OAuth2.1/DCR](/agentkit/connectors/biomnimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bitbucket.svg)](/agentkit/connectors/bitbucket/) [Bitbucket connector](/agentkit/connectors/bitbucket/) [Connect to Bitbucket. Manage repositories, pipelines, pull requests, and code collaboration.](/agentkit/connectors/bitbucket/) [OAuth 2.0](/agentkit/connectors/bitbucket/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bitly.svg)](/agentkit/connectors/bitlymcp/) [Bitly MCP connector](/agentkit/connectors/bitlymcp/) [Connect with Bitly MCP for URL shortening, link analytics, and branded links.](/agentkit/connectors/bitlymcp/) [OAuth 2.1/DCR](/agentkit/connectors/bitlymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bitquery.svg)](/agentkit/connectors/bitquerymcp/) [Bitquery MCP connector](/agentkit/connectors/bitquerymcp/) [Connect to Bitquery MCP. Query on-chain DEX trading data, token prices, OHLCV series, trader profiles, and trending tokens across multiple blockchains...](/agentkit/connectors/bitquerymcp/) [OAuth 2.1/DCR](/agentkit/connectors/bitquerymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bonsai.svg)](/agentkit/connectors/bonsaimcp/) [Bonsai MCP connector](/agentkit/connectors/bonsaimcp/) [Connect to Bonsai, the all-in-one business management platform for freelancers and agencies. Manage projects, tasks, CRM contacts, deals, invoices, and...](/agentkit/connectors/bonsaimcp/) [OAuth2.1/DCR](/agentkit/connectors/bonsaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/box.svg)](/agentkit/connectors/box/) [Box connector](/agentkit/connectors/box/) [Box is a cloud content management platform. Manage files, folders, users, groups, collaborations, tasks, comments, webhooks, search, and more using the...](/agentkit/connectors/box/) [OAuth 2.0](/agentkit/connectors/box/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/box.svg)](/agentkit/connectors/boxmcp/) [Box MCP connector](/agentkit/connectors/boxmcp/) [Connect to Box via MCP to manage files, folders, collaborations, users, groups, tasks, comments, and search content directly from your AI workflows.](/agentkit/connectors/boxmcp/) [OAuth 2.1](/agentkit/connectors/boxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/brave.svg)](/agentkit/connectors/brave/) [Brave Search connector](/agentkit/connectors/brave/) [Connect to Brave Search to perform web, image, video, and news searches with privacy-focused results, plus AI-powered suggestions and spellcheck.](/agentkit/connectors/brave/) [API Key](/agentkit/connectors/brave/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/brevo.svg)](/agentkit/connectors/brevomcp/) [Brevo MCP connector](/agentkit/connectors/brevomcp/) [Connect to Brevo MCP. Manage email and SMS campaigns, transactional emails, contacts, lists, automations, and loyalty programs from your AI workflows.](/agentkit/connectors/brevomcp/) [OAuth 2.1/DCR](/agentkit/connectors/brevomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bugsnag.svg)](/agentkit/connectors/bugsnagmcp/) [Bugsnag MCP connector](/agentkit/connectors/bugsnagmcp/) [Connect to Bugsnag MCP. Monitor errors, releases, traces, and span groups across your projects from your AI workflows.](/agentkit/connectors/bugsnagmcp/) [OAuth 2.1/DCR](/agentkit/connectors/bugsnagmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/buildkite.svg)](/agentkit/connectors/buildkitemcp/) [Buildkite MCP connector](/agentkit/connectors/buildkitemcp/) [Connect to Buildkite MCP. Manage CI/CD pipelines, builds, agents, clusters, and test suites from your AI workflows.](/agentkit/connectors/buildkitemcp/) [OAuth 2.1/DCR](/agentkit/connectors/buildkitemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/cal.svg)](/agentkit/connectors/calmcp/) [Cal MCP connector](/agentkit/connectors/calmcp/) [Connect to Cal MCP. Manage bookings, event types, schedules, and availability from your AI workflows.](/agentkit/connectors/calmcp/) [OAuth 2.1/DCR](/agentkit/connectors/calmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/calendly.svg)](/agentkit/connectors/calendly/) [Calendly connector](/agentkit/connectors/calendly/) [Connect to Calendly. Access user profile, events, and scheduling workflows.](/agentkit/connectors/calendly/) [OAuth 2.0](/agentkit/connectors/calendly/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/calendly.svg)](/agentkit/connectors/calendlymcp/) [Calendly MCP connector](/agentkit/connectors/calendlymcp/) [Connect to the Calendly MCP server to manage scheduled events, invitees, event types, and availability directly from your AI workflows.](/agentkit/connectors/calendlymcp/) [OAuth 2.1/DCR](/agentkit/connectors/calendlymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/candid.svg)](/agentkit/connectors/candidmcp/) [Candid MCP connector](/agentkit/connectors/candidmcp/) [Connect to Candid MCP. Search nonprofit organizations, explore philanthropic data, and classify social sector activities using Candid's knowledge base.](/agentkit/connectors/candidmcp/) [OAuth 2.1/DCR](/agentkit/connectors/candidmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/canva.svg)](/agentkit/connectors/canva/) [Canva connector](/agentkit/connectors/canva/) [Connect to Canva's Connect API to manage designs, assets, folders, brand templates, comments, autofills, exports, and analytics on the user's behalf via...](/agentkit/connectors/canva/) [OAuth 2.0](/agentkit/connectors/canva/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/carbone.svg)](/agentkit/connectors/carboneiomcp/) [Carbone.io MCP connector](/agentkit/connectors/carboneiomcp/) [Connect to Carbone.io MCP. Upload templates, render documents by merging templates with JSON data, convert between 100+ formats, and manage template...](/agentkit/connectors/carboneiomcp/) [Bearer Token](/agentkit/connectors/carboneiomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/carta.svg)](/agentkit/connectors/cartamcp/) [Carta MCP connector](/agentkit/connectors/cartamcp/) [Connect to Carta. Manage equity cap tables, fund administration, company accounts, and ownership data for venture-backed companies.](/agentkit/connectors/cartamcp/) [OAuth 2.1/DCR](/agentkit/connectors/cartamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/catchr.svg)](/agentkit/connectors/catchrmcp/) [Catchr MCP connector](/agentkit/connectors/catchrmcp/) [Catchr is a data connector platform that syncs marketing and analytics data from ad platforms (Google Ads, Facebook Ads, etc.) to data warehouses and BI...](/agentkit/connectors/catchrmcp/) [OAuth2.1/DCR](/agentkit/connectors/catchrmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/chilipiper.svg)](/agentkit/connectors/chilipipermcp/) [ChiliPiper MCP connector](/agentkit/connectors/chilipipermcp/) [Connect to ChiliPiper MCP. Schedule meetings, manage routing rules, track distributions, and automate handoffs from your AI agents.](/agentkit/connectors/chilipipermcp/) [Bearer Token](/agentkit/connectors/chilipipermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/chorus.svg)](/agentkit/connectors/chorus/) [Chorus connector](/agentkit/connectors/chorus/) [Connect to Chorus.ai to sync calls, transcripts, conversation intelligence, and analytics.](/agentkit/connectors/chorus/) [Basic Auth](/agentkit/connectors/chorus/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/circleback.svg)](/agentkit/connectors/circlebackmcp/) [Circleback MCP connector](/agentkit/connectors/circlebackmcp/) [Circleback is an AI meeting notes and conversation intelligence platform. The Circleback MCP server provides a standardized interface that allows any...](/agentkit/connectors/circlebackmcp/) [OAuth 2.1/DCR](/agentkit/connectors/circlebackmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/claap.svg)](/agentkit/connectors/claapmcp/) [Claap MCP connector](/agentkit/connectors/claapmcp/) [Video collaboration platform for recording, sharing, and discussing async video clips — used for meeting recordings, product demos, feedback, and team...](/agentkit/connectors/claapmcp/) [OAuth2.1/DCR](/agentkit/connectors/claapmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clari.svg)](/agentkit/connectors/clari_copilot/) [Clari Copilot connector](/agentkit/connectors/clari_copilot/) [Connect to Clari Copilot for sales call transcripts, analytics, call data, and insights.](/agentkit/connectors/clari_copilot/) [API Key](/agentkit/connectors/clari_copilot/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clarify.svg)](/agentkit/connectors/clarifymcp/) [Clarify MCP connector](/agentkit/connectors/clarifymcp/) [Connect to Clarify MCP to manage CRM records, leads, campaigns, lists, and analytics directly from your AI workflows.](/agentkit/connectors/clarifymcp/) [OAuth 2.1/DCR](/agentkit/connectors/clarifymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clay.svg)](/agentkit/connectors/claymcp/) [Clay MCP connector](/agentkit/connectors/claymcp/) [Clay is a go-to-market (GTM) platform that unifies data sourcing from 150+ providers, AI-powered research agents, and workflow orchestration for sales and...](/agentkit/connectors/claymcp/) [OAuth 2.1/DCR](/agentkit/connectors/claymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clickhouse.svg)](/agentkit/connectors/clickhouse/) [Clickhouse MCP connector](/agentkit/connectors/clickhouse/) [Connect to ClickHouse MCP to query, analyze, and manage your ClickHouse databases directly from your AI workflows.](/agentkit/connectors/clickhouse/) [OAuth 2.1/DCR](/agentkit/connectors/clickhouse/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clickup.svg)](/agentkit/connectors/clickup/) [ClickUp connector](/agentkit/connectors/clickup/) [Connect to ClickUp. Manage tasks, projects, workspaces, and team collaboration](/agentkit/connectors/clickup/) [OAuth 2.0](/agentkit/connectors/clickup/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/close.svg)](/agentkit/connectors/close/) [Close connector](/agentkit/connectors/close/) [Connect to Close CRM. Manage leads, contacts, opportunities, tasks, activities, and sales workflows](/agentkit/connectors/close/) [OAuth 2.0](/agentkit/connectors/close/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/close.svg)](/agentkit/connectors/closemcp/) [Close MCP connector](/agentkit/connectors/closemcp/) [Close is a CRM and sales platform. The Close MCP server provides a standardized interface that allows any compatible AI model or agent to access Close CRM...](/agentkit/connectors/closemcp/) [OAuth 2.1/DCR](/agentkit/connectors/closemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/cloudflare.svg)](/agentkit/connectors/cloudflare/) [Cloudflare connector](/agentkit/connectors/cloudflare/) [Cloudflare is a cloud platform providing DNS management, CDN, security, and networking services. This connector enables automated management of zones, DNS...](/agentkit/connectors/cloudflare/) [OAuth 2.0](/agentkit/connectors/cloudflare/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/cloudflare.svg)](/agentkit/connectors/cloudfaremcp/) [Cloudflare MCP connector](/agentkit/connectors/cloudfaremcp/) [Connect to Cloudflare MCP to manage your Cloudflare account — execute API calls, search the OpenAPI spec, and interact with Workers, R2, D1, KV, and all...](/agentkit/connectors/cloudfaremcp/) [OAuth 2.1/DCR](/agentkit/connectors/cloudfaremcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/cloudinary.svg)](/agentkit/connectors/cloudinarymcp/) [Cloudinary MCP connector](/agentkit/connectors/cloudinarymcp/) [Connects AI agents to Cloudinary's asset management platform, enabling upload, search, transformation, and organization of media assets through natural...](/agentkit/connectors/cloudinarymcp/) [OAuth2.1/DCR](/agentkit/connectors/cloudinarymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/cloudpress.svg)](/agentkit/connectors/cloudpressmcp/) [Cloudpress MCP connector](/agentkit/connectors/cloudpressmcp/) [Cloudpress is a managed WordPress hosting platform built for the AI era. Its MCP server lets AI agents manage sites, domains, DNS, security rules...](/agentkit/connectors/cloudpressmcp/) [OAuth 2.1/DCR](/agentkit/connectors/cloudpressmcp/) [![](https://platform.cognee.ai/icon.svg?icon.3c7f72a5.svg)](/agentkit/connectors/cognee/) [Cognee connector](/agentkit/connectors/cognee/) [Connect to Cognee, an AI memory engine for agents. Remember data into a knowledge graph, recall it with semantic search, improve stored memory, and forget...](/agentkit/connectors/cognee/) [API Key](/agentkit/connectors/cognee/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/coinmarketcap.svg)](/agentkit/connectors/coinmarketcapmcp/) [CoinMarketCap MCP connector](/agentkit/connectors/coinmarketcapmcp/) [Connect to CoinMarketCap MCP. Access real-time crypto quotes, market metrics, technical analysis, trending narratives, and news from your AI workflows.](/agentkit/connectors/coinmarketcapmcp/) [OAuth 2.1/DCR](/agentkit/connectors/coinmarketcapmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/commonroom.svg)](/agentkit/connectors/commonroommcp/) [Commonroom MCP connector](/agentkit/connectors/commonroommcp/) [Connect to Common Room MCP to manage community members, objects, and feedback data directly from your AI workflows.](/agentkit/connectors/commonroommcp/) [OAuth 2.1/DCR](/agentkit/connectors/commonroommcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/confluence.svg)](/agentkit/connectors/confluence/) [Confluence connector](/agentkit/connectors/confluence/) [Connect to Confluence. Manage spaces, pages, content, and team collaboration](/agentkit/connectors/confluence/) [OAuth 2.0](/agentkit/connectors/confluence/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/contentful.svg)](/agentkit/connectors/contentfulmcp/) [Contentful MCP connector](/agentkit/connectors/contentfulmcp/) [Connect to Contentful MCP. Manage spaces, entries, assets, content types, and taxonomies in your Contentful CMS from AI workflows.](/agentkit/connectors/contentfulmcp/) [OAuth 2.1/DCR](/agentkit/connectors/contentfulmcp/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/context7.svg)](/agentkit/connectors/context7mcp/) [Context7 MCP connector](/agentkit/connectors/context7mcp/) [Connect to Context7 MCP to fetch up-to-date, version-specific library documentation and code examples directly from the source.](/agentkit/connectors/context7mcp/) [API Key](/agentkit/connectors/context7mcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/conversiontools.svg)](/agentkit/connectors/conversiontoolsmcp/) [Conversion Tools MCP connector](/agentkit/connectors/conversiontoolsmcp/) [Connect to Conversion Tools MCP. Convert files between 140+ formats including documents, images, audio, video, and data files from your AI workflows.](/agentkit/connectors/conversiontoolsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/conversiontoolsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/convertapi.svg)](/agentkit/connectors/convertapimcp/) [ConvertAPI MCP connector](/agentkit/connectors/convertapimcp/) [Connect to ConvertAPI MCP. Convert, merge, split, and transform files across 200+ formats including PDF, Word, Excel, images, and more.](/agentkit/connectors/convertapimcp/) [OAuth 2.1/DCR](/agentkit/connectors/convertapimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/crustdata.svg)](/agentkit/connectors/crustdatamcp/) [Crustdata MCP connector](/agentkit/connectors/crustdatamcp/) [People and company intelligence platform for candidate sourcing, sales prospecting, and talent intelligence. Provides real-time data on professionals...](/agentkit/connectors/crustdatamcp/) [OAuth 2.1/DCR](/agentkit/connectors/crustdatamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/customerio.svg)](/agentkit/connectors/customeriomcp/) [Customer.io MCP connector](/agentkit/connectors/customeriomcp/) [Connect to Customer.io MCP to manage customers, campaigns, and events](/agentkit/connectors/customeriomcp/) [OAuth 2.1/DCR](/agentkit/connectors/customeriomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dartai.svg)](/agentkit/connectors/dartaimcp/) [Dart AI MCP connector](/agentkit/connectors/dartaimcp/) [AI-native project management tool for task and document management with deep AI integration.](/agentkit/connectors/dartaimcp/) [OAuth2.1/DCR](/agentkit/connectors/dartaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/databox.svg)](/agentkit/connectors/databoxmcp/) [Databox MCP connector](/agentkit/connectors/databoxmcp/) [Connect to Databox MCP. Query metrics, manage dashboards, and push custom data to your Databox analytics and reporting platform.](/agentkit/connectors/databoxmcp/) [OAuth 2.1/DCR](/agentkit/connectors/databoxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/databricks-1.svg)](/agentkit/connectors/databricksworkspace/) [Databricks Workspace connector](/agentkit/connectors/databricksworkspace/) [Connect to Databricks Workspace APIs using a Service Principal with OAuth 2.0 client credentials to manage clusters, jobs, notebooks, SQL, and more.](/agentkit/connectors/databricksworkspace/) [Service Principal (OAuth 2.0)](/agentkit/connectors/databricksworkspace/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/datadog.svg)](/agentkit/connectors/datadog/) [Datadog connector](/agentkit/connectors/datadog/) [Connect to Datadog to monitor metrics, logs, traces, dashboards, monitors, incidents, SLOs, synthetics, and security signals across your infrastructure.](/agentkit/connectors/datadog/) [API Key](/agentkit/connectors/datadog/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dataforseo.svg)](/agentkit/connectors/dataforseomcp/) [Dataforseo MCP connector](/agentkit/connectors/dataforseomcp/) [Connect to DataForSEO. Access real-time SEO data including SERP results, keyword analytics, backlinks analysis, domain technologies, and AI visibility...](/agentkit/connectors/dataforseomcp/) [OAuth 2.1/DCR](/agentkit/connectors/dataforseomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/deel.svg)](/agentkit/connectors/deelmcp/) [Deel MCP connector](/agentkit/connectors/deelmcp/) [Global HR and payroll platform for hiring, paying, and managing international employees and contractors with built-in compliance.](/agentkit/connectors/deelmcp/) [OAuth2.1/DCR](/agentkit/connectors/deelmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/deepgram.svg)](/agentkit/connectors/deepgrammcp/) [Deepgram MCP connector](/agentkit/connectors/deepgrammcp/) [Connect to Deepgram MCP. Transcribe audio, generate speech, and manage transcription projects using Deepgram's AI-powered speech recognition API.](/agentkit/connectors/deepgrammcp/) [OAuth 2.1/DCR](/agentkit/connectors/deepgrammcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/descript.svg)](/agentkit/connectors/descriptmcp/) [Descript MCP connector](/agentkit/connectors/descriptmcp/) [Connect to Descript MCP. Import media, export transcripts, publish projects, run AI editing agents, and manage jobs from your AI workflows.](/agentkit/connectors/descriptmcp/) [OAuth 2.1/DCR](/agentkit/connectors/descriptmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/devrev.svg)](/agentkit/connectors/devrevmcp/) [Dev Rev MCP connector](/agentkit/connectors/devrevmcp/) [Connect to DevRev MCP. Manage issues, work items, conversations, and customer data in the DevRev product development platform.](/agentkit/connectors/devrevmcp/) [Bearer Token](/agentkit/connectors/devrevmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/devin.svg)](/agentkit/connectors/devinmcp/) [Devin MCP connector](/agentkit/connectors/devinmcp/) [Connect to Devin MCP. Create and manage AI coding sessions, interact with Devin agents, manage playbooks and schedules, and browse repository wikis from...](/agentkit/connectors/devinmcp/) [Bearer Token](/agentkit/connectors/devinmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/diarize.svg)](/agentkit/connectors/diarize/) [Diarize connector](/agentkit/connectors/diarize/) [Connect to Diarize to transcribe and diarize audio and video content from YouTube, X, Instagram, and TikTok. Submit transcription jobs and retrieve...](/agentkit/connectors/diarize/) [Bearer Token](/agentkit/connectors/diarize/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/digits.svg)](/agentkit/connectors/digitsmcp/) [Digits MCP connector](/agentkit/connectors/digitsmcp/) [Digits is an AI-powered business finance platform. This MCP connector gives AI agents read-only access to your Digits data — transactions, financial...](/agentkit/connectors/digitsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/digitsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/discord.svg)](/agentkit/connectors/discordbot/) [Discord Bot connector](/agentkit/connectors/discordbot/) [Connect to Discord as a bot. Manage guilds, channels, members, messages, roles, webhooks, and more using a Discord Bot Token.](/agentkit/connectors/discordbot/) [API Key](/agentkit/connectors/discordbot/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/discord.svg)](/agentkit/connectors/discord/) [Discord connector](/agentkit/connectors/discord/) [Connect to Discord. Read user profile, guilds, roles, manage bots, and perform interactions.](/agentkit/connectors/discord/) [OAuth 2.0](/agentkit/connectors/discord/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/docsautomator.svg)](/agentkit/connectors/docsautomatormcp/) [Docsautomator MCP connector](/agentkit/connectors/docsautomatormcp/) [Connect to DocsAutomator MCP. Generate documents and PDFs from templates using your data, automating document creation workflows.](/agentkit/connectors/docsautomatormcp/) [OAuth 2.1/DCR](/agentkit/connectors/docsautomatormcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dovetail.svg)](/agentkit/connectors/dovetailmcp/) [Dovetail MCP connector](/agentkit/connectors/dovetailmcp/) [Connect to Dovetail, the AI-native UX research platform. Access projects, insights, and data from your AI workflows.](/agentkit/connectors/dovetailmcp/) [Bearer Token](/agentkit/connectors/dovetailmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/drop_box.svg)](/agentkit/connectors/dropbox/) [Dropbox connector](/agentkit/connectors/dropbox/) [Connect to Dropbox. Manage files, folders, sharing, and cloud storage workflows](/agentkit/connectors/dropbox/) [OAuth 2.0](/agentkit/connectors/dropbox/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/drop_box.svg)](/agentkit/connectors/dropboxmcp/) [Dropbox MCP connector](/agentkit/connectors/dropboxmcp/) [Connect to Dropbox. Manage files and folders, create shared links, search content, and handle file requests from your AI workflows.](/agentkit/connectors/dropboxmcp/) [OAuth 2.1](/agentkit/connectors/dropboxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dropcontact.svg)](/agentkit/connectors/dropcontactmcp/) [Dropcontact MCP connector](/agentkit/connectors/dropcontactmcp/) [B2B contact enrichment and email verification platform that finds, verifies, and enriches professional email addresses and company data.](/agentkit/connectors/dropcontactmcp/) [OAuth 2.1/DCR](/agentkit/connectors/dropcontactmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dynamo.svg)](/agentkit/connectors/dynamo/) [Dynamo Software connector](/agentkit/connectors/dynamo/) [Connect to Dynamo Software API to access investment management, CRM, and reporting data.](/agentkit/connectors/dynamo/) [Bearer Token](/agentkit/connectors/dynamo/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/echtpost.svg)](/agentkit/connectors/echtpostmcp/) [Echtpost MCP connector](/agentkit/connectors/echtpostmcp/) [Connect to Echtpost MCP. Send physical postcards and letters programmatically via the Echtpost API.](/agentkit/connectors/echtpostmcp/) [OAuth 2.1/DCR](/agentkit/connectors/echtpostmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/eden.svg)](/agentkit/connectors/edenmcp/) [Eden MCP connector](/agentkit/connectors/edenmcp/) [Eden is an AI-powered content creation platform that discovers viral trends across 3M+ social media posts and helps creators generate content in their...](/agentkit/connectors/edenmcp/) [OAuth2.1/DCR](/agentkit/connectors/edenmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/eodhd.svg)](/agentkit/connectors/eodhdmcp/) [EODHD MCP connector](/agentkit/connectors/eodhdmcp/) [EODHD (End of Day Historical Data) provides comprehensive financial market data including end-of-day stock prices, historical OHLCV data, fundamentals...](/agentkit/connectors/eodhdmcp/) [OAuth 2.1/DCR](/agentkit/connectors/eodhdmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/eracontext.svg)](/agentkit/connectors/eracontextmcp/) [Era Context MCP connector](/agentkit/connectors/eracontextmcp/) [Connect to Era Context MCP. Access personal finance data including transactions, accounts, spending insights, and AI-powered financial knowledge from Era.](/agentkit/connectors/eracontextmcp/) [OAuth 2.1/DCR](/agentkit/connectors/eracontextmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/eraser.svg)](/agentkit/connectors/erasermcp/) [Eraser MCP connector](/agentkit/connectors/erasermcp/) [Connect to Eraser MCP. Create and edit diagrams, flowcharts, and technical documentation using Eraser's AI-powered diagramming tools.](/agentkit/connectors/erasermcp/) [OAuth 2.1/DCR](/agentkit/connectors/erasermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/evertrace.png)](/agentkit/connectors/evertrace/) [Evertrace AI connector](/agentkit/connectors/evertrace/) [Connect to evertrace.ai to search and manage talent signals, saved searches, and lists. Access rich professional profiles with scoring, experiences, and...](/agentkit/connectors/evertrace/) [Bearer Token](/agentkit/connectors/evertrace/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/exa.svg)](/agentkit/connectors/exa/) [Exa connector](/agentkit/connectors/exa/) [Connect to Exa to perform AI-powered semantic web search, crawl websites for structured content, get natural language answers from the web, run in-depth...](/agentkit/connectors/exa/) [API Key](/agentkit/connectors/exa/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/exa.svg)](/agentkit/connectors/examcp/) [Exa MCP connector](/agentkit/connectors/examcp/) [Connect to Exa MCP to perform AI-powered semantic web search, crawl websites for structured content, get natural language answers from the web, and run...](/agentkit/connectors/examcp/) [API Key](/agentkit/connectors/examcp/) [![](https://docs.excalidraw.com/img/logo.svg)](/agentkit/connectors/excalidrawmcp/) [Excalidraw MCP connector](/agentkit/connectors/excalidrawmcp/) [Excalidraw+ is a collaborative whiteboard and diagramming platform. The Excalidraw MCP server lets AI agents manage scenes, collections, workspaces...](/agentkit/connectors/excalidrawmcp/) [Bearer Token](/agentkit/connectors/excalidrawmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/expo.svg)](/agentkit/connectors/expomcp/) [Expo MCP connector](/agentkit/connectors/expomcp/) [Expo is a platform for building universal React Native apps; its MCP server exposes developer services including EAS builds, submissions, and project...](/agentkit/connectors/expomcp/) [OAuth2.1/DCR](/agentkit/connectors/expomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fathom.svg)](/agentkit/connectors/fathom/) [Fathom connector](/agentkit/connectors/fathom/) [Connect to Fathom AI meeting assistant. Record, transcribe, and summarize meetings with AI-powered insights](/agentkit/connectors/fathom/) [API Key](/agentkit/connectors/fathom/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fathom.svg)](/agentkit/connectors/fathommcp/) [Fathom MCP connector](/agentkit/connectors/fathommcp/) [Connect to Fathom MCP to access AI meeting notes, summaries, transcripts, and recordings from your AI workflows.](/agentkit/connectors/fathommcp/) [OAuth 2.1/DCR](/agentkit/connectors/fathommcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fellowai.svg)](/agentkit/connectors/fellowaimcp/) [FellowAI MCP connector](/agentkit/connectors/fellowaimcp/) [Connect to Fellow.ai MCP to manage meeting notes, action items, agendas, and team collaboration workflows directly from your AI agent.](/agentkit/connectors/fellowaimcp/) [OAuth 2.1/DCR](/agentkit/connectors/fellowaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fever.svg)](/agentkit/connectors/fevermcp/) [Fever MCP connector](/agentkit/connectors/fevermcp/) [Fever is a live entertainment discovery platform. This MCP connector gives AI assistants direct access to Fever's global event catalog — search events by...](/agentkit/connectors/fevermcp/) [OAuth 2.1/DCR](/agentkit/connectors/fevermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fibery.svg)](/agentkit/connectors/fiberymcp/) [Fibery MCP connector](/agentkit/connectors/fiberymcp/) [Connect to Fibery MCP. Query, create, and update entities across your Fibery workspace using the Fibery API and AI assistant.](/agentkit/connectors/fiberymcp/) [OAuth 2.1/DCR](/agentkit/connectors/fiberymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/figma.svg)](/agentkit/connectors/figma/) [Figma connector](/agentkit/connectors/figma/) [Connect to Figma to access user files, teams, projects, and design metadata via OAuth 2.0](/agentkit/connectors/figma/) [OAuth 2.0](/agentkit/connectors/figma/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/financialdatasets.svg)](/agentkit/connectors/financialdatasetsmcp/) [Financial Datasets MCP connector](/agentkit/connectors/financialdatasetsmcp/) [Financial Datasets provides an MCP interface to financial data APIs covering stock prices, financial statements, earnings, insider trades, and...](/agentkit/connectors/financialdatasetsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/financialdatasetsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/firecrawl.svg)](/agentkit/connectors/firecrawlmcp/) [Firecrawl MCP connector](/agentkit/connectors/firecrawlmcp/) [Connect to Firecrawl MCP. Scrape, crawl, search, extract structured data, and monitor websites using Firecrawl's AI-powered web scraping API.](/agentkit/connectors/firecrawlmcp/) [Bearer Token](/agentkit/connectors/firecrawlmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fireflies.svg)](/agentkit/connectors/firefliesmcp/) [Fireflies MCP connector](/agentkit/connectors/firefliesmcp/) [Connect to Fireflies MCP. Search meeting transcripts, fetch recordings, manage channels, create soundbites, and retrieve analytics from your AI workflows.](/agentkit/connectors/firefliesmcp/) [OAuth 2.1/DCR](/agentkit/connectors/firefliesmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fiscalai.svg)](/agentkit/connectors/fiscalaimcp/) [FiscalAI MCP connector](/agentkit/connectors/fiscalaimcp/) [Connect to FiscalAI MCP. Access financial data for public companies including SEC filings, earnings, stock prices, financial ratios, and company profiles.](/agentkit/connectors/fiscalaimcp/) [OAuth 2.1/DCR](/agentkit/connectors/fiscalaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/flux.svg)](/agentkit/connectors/fluxmcp/) [Flux MCP connector](/agentkit/connectors/fluxmcp/) [Flux by Black Forest Labs provides state-of-the-art AI image generation via the FLUX.1 family of models. Generate high-quality images from text prompts...](/agentkit/connectors/fluxmcp/) [OAuth 2.1/DCR](/agentkit/connectors/fluxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/folk.svg)](/agentkit/connectors/folkmcp/) [Folk MCP connector](/agentkit/connectors/folkmcp/) [Folk is a collaborative CRM that helps teams manage contacts, track relationships, and run outreach — all in one workspace.](/agentkit/connectors/folkmcp/) [OAuth 2.1/DCR](/agentkit/connectors/folkmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/freshdesk.png)](/agentkit/connectors/freshdesk/) [Freshdesk connector](/agentkit/connectors/freshdesk/) [Connect to Freshdesk. Manage tickets, contacts, companies, and customer support workflows](/agentkit/connectors/freshdesk/) [Basic Auth](/agentkit/connectors/freshdesk/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fullenrich.svg)](/agentkit/connectors/fullenrichmcp/) [Fullenrich MCP connector](/agentkit/connectors/fullenrichmcp/) [Connect to FullEnrich MCP. Enrich contacts with verified email addresses and phone numbers using waterfall enrichment across multiple data providers.](/agentkit/connectors/fullenrichmcp/) [OAuth 2.1/DCR](/agentkit/connectors/fullenrichmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gainsight.svg)](/agentkit/connectors/gainsight/) [Gainsight connector](/agentkit/connectors/gainsight/) [Connect to Gainsight Customer Success to manage companies, contacts, calls to action, success plans, timeline activities, and custom objects. Power...](/agentkit/connectors/gainsight/) [API Key](/agentkit/connectors/gainsight/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/github.png)](/agentkit/connectors/githubpat/) [GitHub (Personal Access Token) connector](/agentkit/connectors/githubpat/) [GitHub is a cloud-based Git repository hosting service that allows developers to store, manage, and track changes to their code. This variant...](/agentkit/connectors/githubpat/) [Bearer Token](/agentkit/connectors/githubpat/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/github.png)](/agentkit/connectors/github/) [Github connector](/agentkit/connectors/github/) [GitHub is a cloud-based Git repository hosting service that allows developers to store, manage, and track changes to their code.](/agentkit/connectors/github/) [OAuth 2.0](/agentkit/connectors/github/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/github.png)](/agentkit/connectors/githubmcp/) [GitHub MCP connector](/agentkit/connectors/githubmcp/) [Connect to GitHub MCP. Manage repositories, issues, pull requests, branches, and files directly from your AI workflows.](/agentkit/connectors/githubmcp/) [OAuth 2.1](/agentkit/connectors/githubmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gitlab.svg)](/agentkit/connectors/gitlab/) [GitLab connector](/agentkit/connectors/gitlab/) [Connect to GitLab to manage repositories, issues, merge requests, pipelines, CI/CD, users, groups, and DevOps workflows.](/agentkit/connectors/gitlab/) [OAuth 2.0](/agentkit/connectors/gitlab/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/globalping.svg)](/agentkit/connectors/globalpingmcp/) [Globalping MCP connector](/agentkit/connectors/globalpingmcp/) [Globalping is a global network measurement platform for running ping, traceroute, DNS lookup, HTTP, and MTR tests from hundreds of probe locations...](/agentkit/connectors/globalpingmcp/) [OAuth2.1/DCR](/agentkit/connectors/globalpingmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gmail.svg)](/agentkit/connectors/gmail/) [Gmail connector](/agentkit/connectors/gmail/) [Gmail is Google's cloud based email service that allows you to access your messages from any computer or device with just a web browser.](/agentkit/connectors/gmail/) [OAuth 2.0](/agentkit/connectors/gmail/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gocardless.svg)](/agentkit/connectors/gocardlessmcp/) [GoCardless MCP connector](/agentkit/connectors/gocardlessmcp/) [Connect to GoCardless MCP. Retrieve and list customers, mandates, payments, payouts, refunds, and subscriptions, and explore integration options from your...](/agentkit/connectors/gocardlessmcp/) [OAuth 2.1/DCR](/agentkit/connectors/gocardlessmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gong.svg)](/agentkit/connectors/gong/) [Gong connector](/agentkit/connectors/gong/) [Connect with Gong to sync calls, transcripts, insights, coaching and CRM activity](/agentkit/connectors/gong/) [OAuth 2.0](/agentkit/connectors/gong/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gong.svg)](/agentkit/connectors/gongmcp/) [Gong MCP connector](/agentkit/connectors/gongmcp/) [Connect with Gong MCP to access calls, transcripts, insights, coaching, and sales engagement data via the Model Context Protocol](/agentkit/connectors/gongmcp/) [OAuth2.1](/agentkit/connectors/gongmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_ads.png)](/agentkit/connectors/google_ads/) [Google Ads connector](/agentkit/connectors/google_ads/) [Connect to Google Ads to manage advertising campaigns, analyze performance metrics, and optimize ad spending across Google's advertising platform](/agentkit/connectors/google_ads/) [OAuth 2.0](/agentkit/connectors/google_ads/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bigquery.svg)](/agentkit/connectors/bigquery/) [Google BigQuery connector](/agentkit/connectors/bigquery/) [BigQuery is Google Cloud’s fully-managed enterprise data warehouse for analytics at scale.](/agentkit/connectors/bigquery/) [OAuth 2.0](/agentkit/connectors/bigquery/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google.svg)](/agentkit/connectors/googlebusinessprofile/) [Google Business Profile connector](/agentkit/connectors/googlebusinessprofile/) [Google Business Profile lets businesses manage their presence across Google Search and Maps — business information, locations, performance/insights...](/agentkit/connectors/googlebusinessprofile/) [OAuth 2.0](/agentkit/connectors/googlebusinessprofile/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_calendar.svg)](/agentkit/connectors/googlecalendar/) [Google Calendar connector](/agentkit/connectors/googlecalendar/) [Google Calendar is Google's cloud-based calendar service that allows you to manage your events, appointments, and schedules from any computer or device...](/agentkit/connectors/googlecalendar/) [OAuth 2.0](/agentkit/connectors/googlecalendar/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_docs.svg)](/agentkit/connectors/googledocs/) [Google Docs connector](/agentkit/connectors/googledocs/) [Connect to Google Docs. Create, edit, and collaborate on documents](/agentkit/connectors/googledocs/) [OAuth 2.0](/agentkit/connectors/googledocs/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_drive.svg)](/agentkit/connectors/googledrive/) [Google Drive connector](/agentkit/connectors/googledrive/) [Connect to Google Drive. Manage files, folders, and sharing permissions](/agentkit/connectors/googledrive/) [OAuth 2.0](/agentkit/connectors/googledrive/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_forms.svg)](/agentkit/connectors/googleforms/) [Google Forms connector](/agentkit/connectors/googleforms/) [Connect to Google Forms. Create, view, and manage forms and responses securely](/agentkit/connectors/googleforms/) [OAuth 2.0](/agentkit/connectors/googleforms/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/googlelooker.svg)](/agentkit/connectors/googlelooker/) [Google Looker connector](/agentkit/connectors/googlelooker/) [Connect to Google Looker or self-hosted Looker Core. Browse dashboards, run Looks, query LookML models, and access BI data programmatically.](/agentkit/connectors/googlelooker/) [OAuth 2.0](/agentkit/connectors/googlelooker/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_meet.svg)](/agentkit/connectors/googlemeet/) [Google Meet connector](/agentkit/connectors/googlemeet/) [Connect to Google Meet. Create and manage video meetings with powerful collaboration features](/agentkit/connectors/googlemeet/) [OAuth 2.0](/agentkit/connectors/googlemeet/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_sheets.svg)](/agentkit/connectors/googlesheets/) [Google Sheets connector](/agentkit/connectors/googlesheets/) [Connect to Google Sheets. Create, edit, and analyze spreadsheets with powerful data management capabilities](/agentkit/connectors/googlesheets/) [OAuth 2.0](/agentkit/connectors/googlesheets/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_slides.svg)](/agentkit/connectors/googleslides/) [Google Slides connector](/agentkit/connectors/googleslides/) [Connect to Google Slides to create, read, and modify presentations programmatically.](/agentkit/connectors/googleslides/) [OAuth 2.0](/agentkit/connectors/googleslides/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google.svg)](/agentkit/connectors/googledwd/) [Google Workspace (DWD) connector](/agentkit/connectors/googledwd/) [Connect to Google Workspace APIs (Gmail, Drive, Docs, Sheets, Slides, Forms) using a GCP service account with Domain-Wide Delegation for server-to-server...](/agentkit/connectors/googledwd/) [Service Account (DWD)](/agentkit/connectors/googledwd/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gorgias.svg)](/agentkit/connectors/gorgiasmcp/) [Gorgias MCP connector](/agentkit/connectors/gorgiasmcp/) [Customer support helpdesk for e-commerce brands. Centralizes conversations from email, chat, social media, and SMS with ticket management and automation.](/agentkit/connectors/gorgiasmcp/) [OAuth2.1/DCR](/agentkit/connectors/gorgiasmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/grain.svg)](/agentkit/connectors/grainmcp/) [Grain MCP connector](/agentkit/connectors/grainmcp/) [Grain is a meeting recording and intelligence platform. Use this connector to search and retrieve meeting recordings, transcripts, notes, action items...](/agentkit/connectors/grainmcp/) [OAuth 2.1/DCR](/agentkit/connectors/grainmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/granola.svg)](/agentkit/connectors/granola/) [Granola connector](/agentkit/connectors/granola/) [Connect to Granola to access AI-generated meeting notes, summaries, transcripts, and attendee data from your workspace. Granola automatically records and...](/agentkit/connectors/granola/) [Bearer Token](/agentkit/connectors/granola/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/granola.svg)](/agentkit/connectors/granolamcp/) [Granola MCP connector](/agentkit/connectors/granolamcp/) [Connect to Granola MCP using OAuth 2.1 with MCP discovery and dynamic client registration.](/agentkit/connectors/granolamcp/) [OAuth 2.1/DCR](/agentkit/connectors/granolamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/greptile.svg)](/agentkit/connectors/greptilmcp/) [Greptile MCP connector](/agentkit/connectors/greptilmcp/) [AI-powered code search and understanding API that indexes GitHub and GitLab repositories, enabling natural language queries over codebases.](/agentkit/connectors/greptilmcp/) [OAuth2.1/DCR](/agentkit/connectors/greptilmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gtmetrix.svg)](/agentkit/connectors/gtmetrixmcp/) [GTmetrix MCP connector](/agentkit/connectors/gtmetrixmcp/) [Connect to GTmetrix MCP to analyze web page performance, run speed tests, monitor Core Web Vitals, and get actionable optimization recommendations...](/agentkit/connectors/gtmetrixmcp/) [OAuth 2.1/DCR](/agentkit/connectors/gtmetrixmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gusto.svg)](/agentkit/connectors/gustomcp/) [Gusto MCP connector](/agentkit/connectors/gustomcp/) [Connect to Gusto MCP. Manage employees, contractors, payroll, departments, and company data from your AI workflows.](/agentkit/connectors/gustomcp/) [OAuth 2.1/DCR](/agentkit/connectors/gustomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/happyscribe.svg)](/agentkit/connectors/happyscribemcp/) [HappyScribe connector](/agentkit/connectors/happyscribemcp/) [HappyScribe is an AI-powered transcription and translation service. Connect your HappyScribe account to search transcripts, generate meeting summaries...](/agentkit/connectors/happyscribemcp/) [OAuth2.1/DCR](/agentkit/connectors/happyscribemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/harvestapp.svg)](/agentkit/connectors/harvestmcp/) [Harvest MCP connector](/agentkit/connectors/harvestmcp/) [Harvest is a time tracking and invoicing tool that helps teams track time, manage projects, and create invoices.](/agentkit/connectors/harvestmcp/) [OAuth2.1/DCR](/agentkit/connectors/harvestmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/harvestapi.svg)](/agentkit/connectors/harvestapi/) [HarvestAPI connector](/agentkit/connectors/harvestapi/) [Connect to HarvestAPI to scrape LinkedIn profiles, companies, and job listings, and search for people and jobs using LinkedIn data. Enables AI agents to...](/agentkit/connectors/harvestapi/) [API Key](/agentkit/connectors/harvestapi/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/hex.svg)](/agentkit/connectors/hexmcp/) [Hex MCP connector](/agentkit/connectors/hexmcp/) [Connect to Hex MCP. Create and continue data analysis threads, search projects, and query your data using natural language from your AI workflows.](/agentkit/connectors/hexmcp/) [OAuth 2.1/DCR](/agentkit/connectors/hexmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/heyreach.svg)](/agentkit/connectors/heyreach/) [HeyReach connector](/agentkit/connectors/heyreach/) [Connect to HeyReach to manage LinkedIn outreach campaigns, lead lists, and conversations. List campaigns, retrieve leads, monitor campaign progress, and...](/agentkit/connectors/heyreach/) [API Key](/agentkit/connectors/heyreach/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/hub_spot.svg)](/agentkit/connectors/hubspot/) [HubSpot connector](/agentkit/connectors/hubspot/) [Connect to HubSpot CRM. Manage contacts, deals, companies, and marketing automation](/agentkit/connectors/hubspot/) [OAuth 2.0](/agentkit/connectors/hubspot/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/hub_spot.svg)](/agentkit/connectors/hubspotmcp/) [HubSpot MCP connector](/agentkit/connectors/hubspotmcp/) [Connect to HubSpot MCP. Manage CRM contacts, companies, deals, landing pages, campaigns, and analytics from your AI workflows.](/agentkit/connectors/hubspotmcp/) [OAuth 2.1](/agentkit/connectors/hubspotmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/huggingface.svg)](/agentkit/connectors/huggingfacemcp/) [Hugging face MCP connector](/agentkit/connectors/huggingfacemcp/) [Connect to Hugging Face MCP. Search and manage models, datasets, spaces, and collections on the Hugging Face Hub.](/agentkit/connectors/huggingfacemcp/) [OAuth 2.1/DCR](/agentkit/connectors/huggingfacemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/icepanel.png)](/agentkit/connectors/icepanelmcp/) [IcePanel MCP connector](/agentkit/connectors/icepanelmcp/) [Connect your IcePanel software architecture models to AI agents. Query and update your C4 model landscapes — systems, apps, components, connections, and...](/agentkit/connectors/icepanelmcp/) [OAuth 2.1/DCR](/agentkit/connectors/icepanelmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/igpt.svg)](/agentkit/connectors/igptmcp/) [IGPT MCP connector](/agentkit/connectors/igptmcp/) [IGPT is an AI assistant platform that exposes its capabilities via an MCP server, enabling agents to interact with AI-powered tools and workflows.](/agentkit/connectors/igptmcp/) [OAuth2.1/DCR](/agentkit/connectors/igptmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/intercom.svg)](/agentkit/connectors/intercom/) [Intercom connector](/agentkit/connectors/intercom/) [Connect to Intercom. Send messages, manage conversations, and interact with users and contacts.](/agentkit/connectors/intercom/) [OAuth 2.0](/agentkit/connectors/intercom/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jam.svg)](/agentkit/connectors/jammcp/) [Jam MCP connector](/agentkit/connectors/jammcp/) [Connect to Jam MCP. Access bug reports, console logs, network requests, user events, and video transcripts from your AI workflows.](/agentkit/connectors/jammcp/) [OAuth 2.1/DCR](/agentkit/connectors/jammcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jentic.svg)](/agentkit/connectors/jenticmcp/) [Jentic MCP connector](/agentkit/connectors/jenticmcp/) [Connect to Jentic MCP. Search available API actions, load execution details, manage credentials, and execute API operations from your AI workflows.](/agentkit/connectors/jenticmcp/) [OAuth 2.1/DCR](/agentkit/connectors/jenticmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jiminny.svg)](/agentkit/connectors/jiminny/) [Jiminny connector](/agentkit/connectors/jiminny/) [Connect with Jiminny to access call recordings, transcripts, coaching insights, and conversation intelligence data.](/agentkit/connectors/jiminny/) [Bearer Token](/agentkit/connectors/jiminny/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jira.svg)](/agentkit/connectors/jira/) [Jira connector](/agentkit/connectors/jira/) [Connect to Jira. Manage issues, projects, workflows, and agile development processes](/agentkit/connectors/jira/) [OAuth 2.0](/agentkit/connectors/jira/) [![](https://wac-cdn.atlassian.com/dam/jcr:be09430e-3f78-4712-a953-ddcbe01ea541/jsd-icon.svg?cdnVersion=3478)](/agentkit/connectors/jiraservicemanagement/) [Jira Service Management connector](/agentkit/connectors/jiraservicemanagement/) [Connect to Jira Service Management. Manage customer requests, service desks, organizations, knowledge base articles, SLAs, and queues](/agentkit/connectors/jiraservicemanagement/) [OAuth 2.0](/agentkit/connectors/jiraservicemanagement/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jotform.svg)](/agentkit/connectors/jotformmcp/) [Jotform MCP connector](/agentkit/connectors/jotformmcp/) [Connect to Jotform MCP. Create and edit forms, retrieve submissions, assign forms, and search assets from your AI workflows.](/agentkit/connectors/jotformmcp/) [OAuth 2.1/DCR](/agentkit/connectors/jotformmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/kit.svg)](/agentkit/connectors/kitmcp/) [Kit MCP connector](/agentkit/connectors/kitmcp/) [Connect to Kit MCP. Manage email subscribers, sequences, broadcasts, tags, and forms for your email marketing workflows.](/agentkit/connectors/kitmcp/) [OAuth 2.1/DCR](/agentkit/connectors/kitmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/klaviyo.svg)](/agentkit/connectors/klaviyomcp/) [Klaviyo MCP connector](/agentkit/connectors/klaviyomcp/) [Connect to Klaviyo MCP. Report, strategize & create with real-time Klaviyo data](/agentkit/connectors/klaviyomcp/) [OAuth 2.1/DCR](/agentkit/connectors/klaviyomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/kling.svg)](/agentkit/connectors/klingmcp/) [Kling AI MCP connector](/agentkit/connectors/klingmcp/) [Kling AI is a video and image generation platform. This MCP connector exposes Kling AI capabilities — including video generation and image generation —...](/agentkit/connectors/klingmcp/) [OAuth2.1/DCR](/agentkit/connectors/klingmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/latch.svg)](/agentkit/connectors/latchbiomcp/) [Latch Bio MCP connector](/agentkit/connectors/latchbiomcp/) [Latch Bio is a cloud bioinformatics platform for running computational biology workflows. Its MCP server lets AI agents list and retrieve files, manage...](/agentkit/connectors/latchbiomcp/) [OAuth 2.1/DCR](/agentkit/connectors/latchbiomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/launchdarkly.svg)](/agentkit/connectors/launchdarklymcp/) [LaunchDarkly MCP connector](/agentkit/connectors/launchdarklymcp/) [Connect to LaunchDarkly's hosted MCP server to manage feature flags, experiments, and release controls directly from your AI workflows.](/agentkit/connectors/launchdarklymcp/) [OAuth2.1/DCR](/agentkit/connectors/launchdarklymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/leadboxer.svg)](/agentkit/connectors/leadboxermcp/) [LeadBoxer MCP connector](/agentkit/connectors/leadboxermcp/) [Connect to LeadBoxer MCP to identify anonymous website visitors and enrich them with firmographic data. LeadBoxer is a B2B lead generation and website...](/agentkit/connectors/leadboxermcp/) [OAuth 2.1/DCR](/agentkit/connectors/leadboxermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/leadfeeder.svg)](/agentkit/connectors/leadfeedermcp/) [Leadfeeder MCP connector](/agentkit/connectors/leadfeedermcp/) [Connect to Leadfeeder's MCP server to identify website visitors, track B2B leads, and surface company-level intent data directly from your AI workflows.](/agentkit/connectors/leadfeedermcp/) [OAuth2.1/DCR](/agentkit/connectors/leadfeedermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/leadiq.svg)](/agentkit/connectors/leadiq/) [LeadIQ connector](/agentkit/connectors/leadiq/) [Connect to LeadIQ to search and enrich B2B contacts and companies with verified emails, direct dials, and mobile numbers. Build prospect lists and power...](/agentkit/connectors/leadiq/) [API Key](/agentkit/connectors/leadiq/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/leadiq.svg)](/agentkit/connectors/leadiqmcp/) [LeadIQ MCP connector](/agentkit/connectors/leadiqmcp/) [Connect to LeadIQ via MCP to search and enrich B2B contacts and companies. Access real-time prospect data, company intelligence, and email/phone...](/agentkit/connectors/leadiqmcp/) [OAuth2.1/DCR](/agentkit/connectors/leadiqmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/legaldatahunter.svg)](/agentkit/connectors/legaldatahuntermcp/) [Legal Data Hunter MCP connector](/agentkit/connectors/legaldatahuntermcp/) [Connect to Legal Data Hunter MCP. Search and explore indexed legal data sources worldwide, tracking case law, courts, dockets, and legal data coverage...](/agentkit/connectors/legaldatahuntermcp/) [OAuth 2.1/DCR](/agentkit/connectors/legaldatahuntermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lemlist.svg)](/agentkit/connectors/lemlistmcp/) [Lemlist MCP connector](/agentkit/connectors/lemlistmcp/) [Connect to Lemlist MCP. Manage outbound sales campaigns, leads, email sequences, and LinkedIn outreach from your AI workflows.](/agentkit/connectors/lemlistmcp/) [OAuth 2.1/DCR](/agentkit/connectors/lemlistmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lilt.svg)](/agentkit/connectors/liltmcp/) [LILT MCP connector](/agentkit/connectors/liltmcp/) [LILT is an enterprise translation platform that combines AI speed with human expertise to deliver accurate, domain-specific translations at scale. This...](/agentkit/connectors/liltmcp/) [OAuth 2.1/DCR](/agentkit/connectors/liltmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/linear.svg)](/agentkit/connectors/linear/) [Linear connector](/agentkit/connectors/linear/) [Connect to Linear. Manage issues, projects, sprints, and development workflows](/agentkit/connectors/linear/) [OAuth 2.0](/agentkit/connectors/linear/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/linear.svg)](/agentkit/connectors/linearmcp/) [Linear MCP connector](/agentkit/connectors/linearmcp/) [Connect to Linear's hosted MCP server to manage issues, projects, cycles, and comments directly from your AI workflows.](/agentkit/connectors/linearmcp/) [OAuth 2.1/DCR](/agentkit/connectors/linearmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/linkedin.svg)](/agentkit/connectors/linkedin/) [LinkedIn connector](/agentkit/connectors/linkedin/) [Connect to LinkedIn to manage posts, ads, organizations, analytics, and professional profiles from your AI workflows.](/agentkit/connectors/linkedin/) [OAuth 2.0](/agentkit/connectors/linkedin/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/linkly.png)](/agentkit/connectors/linklymcp/) [LinklyHQ MCP connector](/agentkit/connectors/linklymcp/) [LinklyHQ is a URL shortening and link management platform offering click analytics, custom domains, UTM tracking, QR codes, and webhook integrations for...](/agentkit/connectors/linklymcp/) [OAuth 2.1/PKCE](/agentkit/connectors/linklymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/listenlabs.svg)](/agentkit/connectors/listenlabsmcp/) [ListenLabs MCP connector](/agentkit/connectors/listenlabsmcp/) [Listen Labs is a qualitative research platform for creating, launching, and analyzing studies with AI assistance. This MCP connector gives AI agents...](/agentkit/connectors/listenlabsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/listenlabsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/logrocket.svg)](/agentkit/connectors/logrocketmcp/) [LogRocket MCP connector](/agentkit/connectors/logrocketmcp/) [Connect to LogRocket to access session data, query analytics, investigate user-reported issues, and detect regressions directly from your AI workflows.](/agentkit/connectors/logrocketmcp/) [OAuth2.1/DCR](/agentkit/connectors/logrocketmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/loops.svg)](/agentkit/connectors/loopsmcp/) [Loops MCP connector](/agentkit/connectors/loopsmcp/) [Connect to Loops MCP. Create and manage loops and tasks, set priorities, track work queue stats, and ship completed loops from your AI workflows.](/agentkit/connectors/loopsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/loopsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lucid.svg)](/agentkit/connectors/lucidmcp/) [Lucid MCP connector](/agentkit/connectors/lucidmcp/) [Connect to Lucid. Create and edit Lucidchart diagrams, Lucidspark boards, and Lucidscale visualizations from your AI workflows.](/agentkit/connectors/lucidmcp/) [OAuth 2.1/DCR](/agentkit/connectors/lucidmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lunarcrush.svg)](/agentkit/connectors/lunarcrushmcp/) [Lunarcrush MCP connector](/agentkit/connectors/lunarcrushmcp/) [Connect to LunarCrush MCP. Access social intelligence, sentiment analytics, and market data for crypto assets from your AI workflows.](/agentkit/connectors/lunarcrushmcp/) [OAuth 2.1/DCR](/agentkit/connectors/lunarcrushmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lusha.svg)](/agentkit/connectors/lushamcp/) [Lusha MCP connector](/agentkit/connectors/lushamcp/) [Connect to Lusha MCP. Search and enrich B2B contacts and companies, find lookalikes, run prospecting searches, and access intent and activity signals from...](/agentkit/connectors/lushamcp/) [API Key](/agentkit/connectors/lushamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/magicpatterns.svg)](/agentkit/connectors/magicpatternsmcp/) [Magic Patterns MCP connector](/agentkit/connectors/magicpatternsmcp/) [Connect to Magic Patterns, the AI-powered UI design tool. Generate, edit, and manage design components and artifacts from your AI workflows.](/agentkit/connectors/magicpatternsmcp/) [OAuth2.1/DCR](/agentkit/connectors/magicpatternsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mailchimp.svg)](/agentkit/connectors/mailchimp/) [Mailchimp connector](/agentkit/connectors/mailchimp/) [Connect to Mailchimp to manage audiences, campaigns, templates, automations, and reports.](/agentkit/connectors/mailchimp/) [OAuth 2.0](/agentkit/connectors/mailchimp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mailercloud.svg)](/agentkit/connectors/mailercloudmcp/) [Mailercloud MCP connector](/agentkit/connectors/mailercloudmcp/) [Connect to Mailer Cloud MCP. Manage email campaigns, subscriber lists, and automation workflows for your email marketing operations.](/agentkit/connectors/mailercloudmcp/) [OAuth 2.1/DCR](/agentkit/connectors/mailercloudmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mailerlite.svg)](/agentkit/connectors/mailerlitemcp/) [Mailerlite MCP connector](/agentkit/connectors/mailerlitemcp/) [Connect to MailerLite MCP. Manage email campaigns, subscribers, groups, automations, and forms from your AI workflows.](/agentkit/connectors/mailerlitemcp/) [OAuth 2.1/DCR](/agentkit/connectors/mailerlitemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mailgun.svg)](/agentkit/connectors/mailgun/) [Mailgun connector](/agentkit/connectors/mailgun/) [Connect to Mailgun to send transactional and marketing email, manage domains and DNS/DKIM security, mailing lists, suppressions (bounces, complaints...](/agentkit/connectors/mailgun/) [API Key](/agentkit/connectors/mailgun/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mailtrap.svg)](/agentkit/connectors/mailtrap/) [Mailtrap connector](/agentkit/connectors/mailtrap/) [Mailtrap is an email delivery platform for developers that provides transactional and bulk email sending, email sandbox testing, and deliverability tools....](/agentkit/connectors/mailtrap/) [Bearer Token](/agentkit/connectors/mailtrap/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/make.svg)](/agentkit/connectors/makemcp/) [Make MCP connector](/agentkit/connectors/makemcp/) [Connect to Make (formerly Integromat). Build, run, and manage automation scenarios, data stores, webhooks, and connections across thousands of apps from...](/agentkit/connectors/makemcp/) [OAuth 2.1/DCR](/agentkit/connectors/makemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mem.svg)](/agentkit/connectors/memmcp/) [Mem MCP connector](/agentkit/connectors/memmcp/) [A hosted MCP server that gives AI tools secure access to your Mem notes and collections — enabling AI agents to read, create, search, and organize notes...](/agentkit/connectors/memmcp/) [OAuth2.1/DCR](/agentkit/connectors/memmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mem0.svg)](/agentkit/connectors/mem0mcp/) [Mem0 MCP connector](/agentkit/connectors/mem0mcp/) [Connect to Mem0 MCP. Store, search, and retrieve persistent memory for AI agents and applications using semantic search.](/agentkit/connectors/mem0mcp/) [OAuth 2.1/DCR](/agentkit/connectors/mem0mcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/memberstack.svg)](/agentkit/connectors/memberstackmcp/) [Memberstack MCP connector](/agentkit/connectors/memberstackmcp/) [Connect to Memberstack MCP. Manage members, plans, form submissions, and permissions for your membership-based application.](/agentkit/connectors/memberstackmcp/) [OAuth 2.1/DCR](/agentkit/connectors/memberstackmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mercury.svg)](/agentkit/connectors/mercurymcp/) [Mercury MCP connector](/agentkit/connectors/mercurymcp/) [Connect to Mercury. Access accounts, transactions, recipients, invoices, treasury, webhooks, and approval requests for startup banking workflows.](/agentkit/connectors/mercurymcp/) [OAuth 2.1/DCR](/agentkit/connectors/mercurymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/metaview.svg)](/agentkit/connectors/metaviewmcp/) [Metaview MCP connector](/agentkit/connectors/metaviewmcp/) [Metaview is an agentic recruiting platform that automates end-to-end hiring workflows — from candidate sourcing and outreach to interview note-taking and...](/agentkit/connectors/metaviewmcp/) [OAuth 2.1/DCR](/agentkit/connectors/metaviewmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/metricool.svg)](/agentkit/connectors/metricoolmcp/) [Metricool MCP connector](/agentkit/connectors/metricoolmcp/) [Metricool is a social media analytics and scheduling platform for managing, analyzing, and scheduling content across Instagram, Twitter/X, Facebook...](/agentkit/connectors/metricoolmcp/) [OAuth2.1/DCR](/agentkit/connectors/metricoolmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/microsoft365.svg)](/agentkit/connectors/microsoft365/) [Microsoft 365 connector](/agentkit/connectors/microsoft365/) [Connect to Microsoft 365. Unified access to Outlook, Excel, Word, OneNote, OneDrive, SharePoint, and Teams through Microsoft Graph API.](/agentkit/connectors/microsoft365/) [OAuth 2.0](/agentkit/connectors/microsoft365/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/excel.svg)](/agentkit/connectors/microsoftexcel/) [Microsoft Excel connector](/agentkit/connectors/microsoftexcel/) [Connect to Microsoft Excel. Access, read, and modify spreadsheets stored in OneDrive or SharePoint through Microsoft Graph API.](/agentkit/connectors/microsoftexcel/) [OAuth 2.0](/agentkit/connectors/microsoftexcel/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/word.svg)](/agentkit/connectors/microsoftword/) [Microsoft Word connector](/agentkit/connectors/microsoftword/) [Connect to Microsoft Word. Authenticate with your Microsoft account to create, read, and edit Word documents stored in OneDrive or SharePoint through...](/agentkit/connectors/microsoftword/) [OAuth 2.0](/agentkit/connectors/microsoftword/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/minicoursegenerator.svg)](/agentkit/connectors/minicoursegeneratormcp/) [Mini Course Generator MCP connector](/agentkit/connectors/minicoursegeneratormcp/) [Mini Course Generator is a platform for creating and publishing short, focused online mini-courses. It enables creators to build bite-sized educational...](/agentkit/connectors/minicoursegeneratormcp/) [OAuth2.1/DCR](/agentkit/connectors/minicoursegeneratormcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mintlify.svg)](/agentkit/connectors/mintlifymcp/) [Mintlify MCP connector](/agentkit/connectors/mintlifymcp/) [Connect to Mintlify MCP. Read and edit documentation pages, manage navigation nodes, search content, and publish changes via pull requests from your AI...](/agentkit/connectors/mintlifymcp/) [OAuth 2.1/DCR](/agentkit/connectors/mintlifymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/Miro.svg)](/agentkit/connectors/miro/) [Miro connector](/agentkit/connectors/miro/) [Miro is a visual collaboration platform for teams. Manage boards, sticky notes, shapes, cards, frames, connectors, images, and tags using the Miro REST...](/agentkit/connectors/miro/) [OAuth 2.0](/agentkit/connectors/miro/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/Miro.svg)](/agentkit/connectors/miromcp/) [Miro MCP connector](/agentkit/connectors/miromcp/) [Connect to Miro MCP to create and manage boards, frames, sticky notes, shapes, diagrams, and comments directly from your AI workflows.](/agentkit/connectors/miromcp/) [OAuth 2.1/DCR](/agentkit/connectors/miromcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mixmax.svg)](/agentkit/connectors/mixmaxmcp/) [Mixmax MCP connector](/agentkit/connectors/mixmaxmcp/) [Connect to Mixmax MCP. Manage email sequences, templates, contacts, and engagement analytics from your AI workflows.](/agentkit/connectors/mixmaxmcp/) [OAuth 2.1/DCR](/agentkit/connectors/mixmaxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mixpanel.svg)](/agentkit/connectors/mixpanelanalytics/) [Mixpanel Analytics connector](/agentkit/connectors/mixpanelanalytics/) [Connect to Mixpanel's Query API, Lexicon Schemas, and Warehouse Connectors to run segmentation, funnel, retention, and Insights reports, execute custom...](/agentkit/connectors/mixpanelanalytics/) [Service Account](/agentkit/connectors/mixpanelanalytics/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mixpanel.svg)](/agentkit/connectors/mixpanelcompliance/) [Mixpanel Compliance connector](/agentkit/connectors/mixpanelcompliance/) [Connect to Mixpanel's GDPR/CCPA compliance API to submit and track end-user data deletion (right to erasure) and data retrieval (subject access) requests....](/agentkit/connectors/mixpanelcompliance/) [Bearer Token](/agentkit/connectors/mixpanelcompliance/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mixpanel.svg)](/agentkit/connectors/mixpanelingestion/) [Mixpanel Ingestion connector](/agentkit/connectors/mixpanelingestion/) [Connect to Mixpanel's Ingestion API to track events, manage user and group profiles, resolve identities, replace lookup tables, and evaluate feature...](/agentkit/connectors/mixpanelingestion/) [Service Account](/agentkit/connectors/mixpanelingestion/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mobbins.svg)](/agentkit/connectors/mobbinmcp/) [Mobbin MCP connector](/agentkit/connectors/mobbinmcp/) [Connect to Mobbin's MCP server to search real-world UI and UX design references from mobile apps, web apps, and websites using natural language. Returns...](/agentkit/connectors/mobbinmcp/) [OAuth2.1/DCR](/agentkit/connectors/mobbinmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/monday.svg)](/agentkit/connectors/mondaymcp/) [Monday MCP connector](/agentkit/connectors/mondaymcp/) [Connect to the monday.com MCP server to manage boards, items, columns, docs, and workflows directly from your AI agents.](/agentkit/connectors/mondaymcp/) [OAuth 2.1/DCR](/agentkit/connectors/mondaymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/monday.svg)](/agentkit/connectors/monday/) [Monday.com connector](/agentkit/connectors/monday/) [Connect to Monday.com. Manage boards, tasks, workflows, teams, and project collaboration](/agentkit/connectors/monday/) [OAuth 2.0](/agentkit/connectors/monday/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/motherduck.svg)](/agentkit/connectors/motherduckmcp/) [MotherDuck MCP connector](/agentkit/connectors/motherduckmcp/) [Connect to MotherDuck MCP. Query and analyze DuckDB databases, explore schemas, create visualizations, and automate data workflows from your AI workflows.](/agentkit/connectors/motherduckmcp/) [OAuth 2.1/DCR](/agentkit/connectors/motherduckmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/motion.svg)](/agentkit/connectors/motionmcp/) [Motion MCP connector](/agentkit/connectors/motionmcp/) [Connect to Motion MCP. Manage tasks, projects, workspaces, and schedules in the Motion AI-powered project management platform.](/agentkit/connectors/motionmcp/) [OAuth 2.1/DCR](/agentkit/connectors/motionmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mtnewswires.svg)](/agentkit/connectors/mtnewswiresmcp/) [MT Newswires MCP connector](/agentkit/connectors/mtnewswiresmcp/) [Connect to the MT Newswires MCP server on viaNexus to search and retrieve real-time, low-latency financial news across equities, fixed income...](/agentkit/connectors/mtnewswiresmcp/) [OAuth 2.1/DCR](/agentkit/connectors/mtnewswiresmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mux.svg)](/agentkit/connectors/muxmcp/) [Mux MCP connector](/agentkit/connectors/muxmcp/) [Mux is a video infrastructure platform for developers, providing APIs for video hosting, on-demand streaming, live streaming, and playback with analytics...](/agentkit/connectors/muxmcp/) [OAuth2.1/DCR](/agentkit/connectors/muxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/neon.svg)](/agentkit/connectors/neonmcp/) [Neon MCP connector](/agentkit/connectors/neonmcp/) [Connect to Neon MCP. Manage Neon serverless Postgres databases, projects, branches, and queries from your AI workflows.](/agentkit/connectors/neonmcp/) [OAuth 2.1/DCR](/agentkit/connectors/neonmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/netlify.svg)](/agentkit/connectors/netlifymcp/) [Netlify MCP connector](/agentkit/connectors/netlifymcp/) [Build, deploy, and manage Netlify projects — sites, functions, environment variables, forms, blobs, and edge functions — from AI agents via the Netlify...](/agentkit/connectors/netlifymcp/) [OAuth 2.1/DCR](/agentkit/connectors/netlifymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/nimble.svg)](/agentkit/connectors/nimblemcp/) [Nimble MCP connector](/agentkit/connectors/nimblemcp/) [Connect to Nimble MCP. Search the web across multiple engines, extract content from any URL, crawl websites at scale, discover all URLs on a site, and run...](/agentkit/connectors/nimblemcp/) [Bearer Token](/agentkit/connectors/nimblemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/nocodb.svg)](/agentkit/connectors/nocodbmcp/) [NocoDB MCP connector](/agentkit/connectors/nocodbmcp/) [Connect to NocoDB MCP. Create and manage databases, tables, records, views, and fields from your AI workflows.](/agentkit/connectors/nocodbmcp/) [OAuth 2.1/DCR](/agentkit/connectors/nocodbmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/notion.svg)](/agentkit/connectors/notion/) [Notion connector](/agentkit/connectors/notion/) [Connect to Notion workspace. Create, edit pages, manage databases, and collaborate on content](/agentkit/connectors/notion/) [OAuth 2.0](/agentkit/connectors/notion/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/notion.svg)](/agentkit/connectors/notionmcp/) [Notion MCP connector](/agentkit/connectors/notionmcp/) [Connect to Notion MCP. Create and update pages, databases, comments, and views from your AI workflows.](/agentkit/connectors/notionmcp/) [OAuth 2.1/DCR](/agentkit/connectors/notionmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/onedrive.svg)](/agentkit/connectors/onedrive/) [OneDrive connector](/agentkit/connectors/onedrive/) [Connect to OneDrive. Manage files, folders, and cloud storage with Microsoft OneDrive](/agentkit/connectors/onedrive/) [OAuth 2.0](/agentkit/connectors/onedrive/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/onenote.svg)](/agentkit/connectors/onenote/) [OneNote connector](/agentkit/connectors/onenote/) [Connect to Microsoft OneNote. Access, create, and manage notebooks, sections, and pages stored in OneDrive or SharePoint through Microsoft Graph API.](/agentkit/connectors/onenote/) [OAuth 2.0](/agentkit/connectors/onenote/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/onepage.svg)](/agentkit/connectors/onepagemcp/) [Onepage MCP connector](/agentkit/connectors/onepagemcp/) [Onepage is a website builder platform. The MCP connector lets Claude create, edit, and manage Onepage websites and pages on behalf of the user.](/agentkit/connectors/onepagemcp/) [OAuth2.1/DCR](/agentkit/connectors/onepagemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/openrouter.svg)](/agentkit/connectors/openroutermcp/) [OpenRouter MCP connector](/agentkit/connectors/openroutermcp/) [Connect to OpenRouter's MCP server to access unified LLM routing, model discovery, and generation tools directly from your AI workflows.](/agentkit/connectors/openroutermcp/) [OAuth 2.1/DCR](/agentkit/connectors/openroutermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/otterai.svg)](/agentkit/connectors/otteraimcp/) [OtterAI MCP connector](/agentkit/connectors/otteraimcp/) [Connect to OtterAI MCP. Search meeting recordings, fetch full transcripts, and retrieve user account info from your AI workflows.](/agentkit/connectors/otteraimcp/) [OAuth 2.1/DCR](/agentkit/connectors/otteraimcp/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/outlook.svg)](/agentkit/connectors/outlook/) [Outlook connector](/agentkit/connectors/outlook/) [Connect to Microsoft Outlook. Manage emails, calendar events, contacts, and tasks](/agentkit/connectors/outlook/) [OAuth 2.0](/agentkit/connectors/outlook/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/outreach.png)](/agentkit/connectors/outreach/) [Outreach connector](/agentkit/connectors/outreach/) [Connect with Outreach to manage prospects, accounts, sequences, emails, calls, and sales engagement workflows.](/agentkit/connectors/outreach/) [OAuth 2.0](/agentkit/connectors/outreach/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pagerduty.svg)](/agentkit/connectors/pagerduty/) [PagerDuty connector](/agentkit/connectors/pagerduty/) [Connect to PagerDuty to manage incidents, services, users, teams, escalation policies, schedules, and on-call rotations.](/agentkit/connectors/pagerduty/) [OAuth 2.0](/agentkit/connectors/pagerduty/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pandadoc.svg)](/agentkit/connectors/pandadocmcp/) [Pandadoc MCP connector](/agentkit/connectors/pandadocmcp/) [Connect to PandaDoc MCP. Create, send, and manage documents, templates, and e-signatures directly from your AI workflows.](/agentkit/connectors/pandadocmcp/) [OAuth 2.1/DCR](/agentkit/connectors/pandadocmcp/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/parallel-ai.svg)](/agentkit/connectors/parallelaitaskmcp/) [Parallel AI Task MCP connector](/agentkit/connectors/parallelaitaskmcp/) [Connect to Parallel AI Task MCP to run deep research tasks and task groups directly from your AI workflows.](/agentkit/connectors/parallelaitaskmcp/) [Bearer Token](/agentkit/connectors/parallelaitaskmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pendo.svg)](/agentkit/connectors/pendomcp/) [Pendo MCP connector](/agentkit/connectors/pendomcp/) [Connect to Pendo MCP to access product analytics, user guidance, and engagement data directly from your AI workflows.](/agentkit/connectors/pendomcp/) [OAuth 2.1/DCR](/agentkit/connectors/pendomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/phantombuster.svg)](/agentkit/connectors/phantombuster/) [PhantomBuster connector](/agentkit/connectors/phantombuster/) [Connect to PhantomBuster to automate web scraping and data extraction workflows. Launch, monitor, and manage automation agents that extract data from...](/agentkit/connectors/phantombuster/) [API Key](/agentkit/connectors/phantombuster/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/phantombuster.svg)](/agentkit/connectors/phantombustermcp/) [PhantomBuster MCP connector](/agentkit/connectors/phantombustermcp/) [Connect to PhantomBuster MCP server to launch and manage web automation agents, retrieve scraping outputs, manage leads, and explore workspace resources...](/agentkit/connectors/phantombustermcp/) [OAuth 2.1/DCR](/agentkit/connectors/phantombustermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pipedrive.svg)](/agentkit/connectors/pipedrive/) [Pipedrive connector](/agentkit/connectors/pipedrive/) [Connect to Pipedrive CRM. Manage deals, contacts, organizations, activities, leads, and notes to streamline your sales pipeline.](/agentkit/connectors/pipedrive/) [OAuth 2.0](/agentkit/connectors/pipedrive/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pipedrive.svg)](/agentkit/connectors/pipedrivemcp/) [Pipedrive MCP connector](/agentkit/connectors/pipedrivemcp/) [Connect to Pipedrive CRM via MCP to manage deals, contacts, organizations, leads, activities, and notes directly from your AI workflows.](/agentkit/connectors/pipedrivemcp/) [OAuth2.1/DCR](/agentkit/connectors/pipedrivemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pixelbin.svg)](/agentkit/connectors/pixelbinmcp/) [Pixelbin MCP connector](/agentkit/connectors/pixelbinmcp/) [Image and video transformation, optimization, and management platform.](/agentkit/connectors/pixelbinmcp/) [OAuth2.1/DCR](/agentkit/connectors/pixelbinmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/plain.svg)](/agentkit/connectors/plainmcp/) [Plain MCP connector](/agentkit/connectors/plainmcp/) [Connect to Plain MCP. Manage customer support threads, labels, tenants, Help Center articles, and thread field schemas directly from your AI workflows.](/agentkit/connectors/plainmcp/) [OAuth 2.1/DCR](/agentkit/connectors/plainmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/plane.svg)](/agentkit/connectors/planemcp/) [Plane MCP connector](/agentkit/connectors/planemcp/) [Connect to Plane MCP. Manage projects, work items, cycles, modules, epics, and initiatives in your Plane workspace from AI workflows.](/agentkit/connectors/planemcp/) [OAuth 2.1/DCR](/agentkit/connectors/planemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/planetscale.svg)](/agentkit/connectors/planetscalemcp/) [Planet Scale MCP connector](/agentkit/connectors/planetscalemcp/) [Connect to PlanetScale MCP. Run SQL queries, inspect database branches and schemas, get query performance insights, and manage organizations and invoices...](/agentkit/connectors/planetscalemcp/) [OAuth 2.1/DCR](/agentkit/connectors/planetscalemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/planningcenter.svg)](/agentkit/connectors/planningcentermcp/) [Planning Center MCP connector](/agentkit/connectors/planningcentermcp/) [Planning Center is a church management platform with modules for people (contact database), giving, check-ins, services planning, groups, registrations...](/agentkit/connectors/planningcentermcp/) [OAuth 2.1/DCR](/agentkit/connectors/planningcentermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/posthog-1.svg)](/agentkit/connectors/posthogmcp/) [Posthog MCP connector](/agentkit/connectors/posthogmcp/) [Connect to Posthog MCP to enable your AI agents and tools to directly interact with PostHog's products.](/agentkit/connectors/posthogmcp/) [OAuth 2.1/DCR](/agentkit/connectors/posthogmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/postman.svg)](/agentkit/connectors/postmanmcp/) [Postman MCP connector](/agentkit/connectors/postmanmcp/) [Connect to the Postman MCP server to manage collections, workspaces, environments, and APIs directly from your AI workflows.](/agentkit/connectors/postmanmcp/) [OAuth 2.1/DCR](/agentkit/connectors/postmanmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/postmark.svg)](/agentkit/connectors/postmark/) [Postmark connector](/agentkit/connectors/postmark/) [Send and track transactional and broadcast email with Postmark. Manage templates, message streams, bounces, suppressions, webhooks, and delivery...](/agentkit/connectors/postmark/) [API Key](/agentkit/connectors/postmark/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/prisma.svg)](/agentkit/connectors/prismamcp/) [Prisma MCP connector](/agentkit/connectors/prismamcp/) [Connect to Prisma MCP. Manage Prisma Postgres databases, run SQL queries, handle backups, and manage connection strings from your AI workflows.](/agentkit/connectors/prismamcp/) [OAuth 2.1/DCR](/agentkit/connectors/prismamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/privacy.svg)](/agentkit/connectors/privacymcp/) [Privacy MCP connector](/agentkit/connectors/privacymcp/) [Connect to Privacy MCP. Create and manage virtual cards, set spend limits, pause or close cards, and review transactions from your AI workflows.](/agentkit/connectors/privacymcp/) [OAuth 2.1/DCR](/agentkit/connectors/privacymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/profound.svg)](/agentkit/connectors/profoundmcp/) [Profound MCP connector](/agentkit/connectors/profoundmcp/) [Profound is an AI search visibility and marketing analytics platform that helps brands understand and optimize their presence across AI-powered answer...](/agentkit/connectors/profoundmcp/) [OAuth 2.1/DCR](/agentkit/connectors/profoundmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pylon.svg)](/agentkit/connectors/pylonmcp/) [Pylon MCP connector](/agentkit/connectors/pylonmcp/) [Connect to Pylon MCP. Manage customer issues, accounts, projects, milestones, and tasks from your AI workflows.](/agentkit/connectors/pylonmcp/) [OAuth 2.1/DCR](/agentkit/connectors/pylonmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/Quickbooks.svg)](/agentkit/connectors/quickbooks/) [QuickBooks connector](/agentkit/connectors/quickbooks/) [Connect to QuickBooks Online. Manage customers, vendors, invoices, bills, payments, and financial reports.](/agentkit/connectors/quickbooks/) [OAuth 2.0](/agentkit/connectors/quickbooks/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/quicknode.svg)](/agentkit/connectors/quicknodemcp/) [Quicknode MCP connector](/agentkit/connectors/quicknodemcp/) [Connect to QuickNode MCP. Create and manage blockchain RPC endpoints, configure security rules, set rate limits, and monitor usage and logs from your AI...](/agentkit/connectors/quicknodemcp/) [OAuth 2.1/DCR](/agentkit/connectors/quicknodemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/quizvideo.svg)](/agentkit/connectors/quizvideomcp/) [Quiz.Video MCP connector](/agentkit/connectors/quizvideomcp/) [Quiz.Video is an AI-powered platform for creating short-form quiz and flashcard videos. Transform topics, URLs, or documents into shareable quiz and...](/agentkit/connectors/quizvideomcp/) [OAuth 2.1/DCR](/agentkit/connectors/quizvideomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/readai.svg)](/agentkit/connectors/readaimcp/) [Read AI MCP connector](/agentkit/connectors/readaimcp/) [Connect to Read AI to access your meeting intelligence — transcripts, summaries, action items, and insights from meetings, emails, and chats. Retrieve...](/agentkit/connectors/readaimcp/) [OAuth2.1/DCR](/agentkit/connectors/readaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/recraft.svg)](/agentkit/connectors/recraftmcp/) [Recraft AI MCP connector](/agentkit/connectors/recraftmcp/) [Connect to Recraft AI MCP. Generate AI-powered images, vectors, icons, and mockups from your AI agents using Recraft's creative design tools.](/agentkit/connectors/recraftmcp/) [OAuth 2.1/DCR](/agentkit/connectors/recraftmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/replit.svg)](/agentkit/connectors/replitmcp/) [Replit MCP connector](/agentkit/connectors/replitmcp/) [Connect to Replit MCP. Create, update, and inspect Replit apps from natural-language prompts, list your apps, and resolve apps by name from your AI...](/agentkit/connectors/replitmcp/) [OAuth 2.1/DCR](/agentkit/connectors/replitmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/resend.svg)](/agentkit/connectors/resend/) [Resend connector](/agentkit/connectors/resend/) [Resend is an email API platform for developers. Send transactional and marketing emails, manage sending domains, contacts, audiences, broadcasts...](/agentkit/connectors/resend/) [Bearer Token](/agentkit/connectors/resend/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/revealedai.svg)](/agentkit/connectors/revealedaimcp/) [Revealed AI MCP connector](/agentkit/connectors/revealedaimcp/) [Connect to Revealed AI. Track account signals, buyer personas, and people changes to surface timely outreach actions and account intelligence for B2B...](/agentkit/connectors/revealedaimcp/) [OAuth 2.1/DCR](/agentkit/connectors/revealedaimcp/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/rize.svg)](/agentkit/connectors/rizemcp/) [Rize MCP connector](/agentkit/connectors/rizemcp/) [Connect to Rize MCP using OAuth 2.1 with MCP discovery and dynamic client registration. Access and analyze your time tracking data, projects, clients...](/agentkit/connectors/rizemcp/) [OAuth 2.1/DCR](/agentkit/connectors/rizemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/runware.svg)](/agentkit/connectors/runwaremcp/) [Runware MCP connector](/agentkit/connectors/runwaremcp/) [Connect to Runware's MCP server to generate and edit images, video, audio, and 3D assets using thousands of AI models through a single API.](/agentkit/connectors/runwaremcp/) [OAuth2.1/DCR](/agentkit/connectors/runwaremcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sales_force.svg)](/agentkit/connectors/salesforce/) [Salesforce connector](/agentkit/connectors/salesforce/) [Connect to Salesforce CRM. Manage leads, opportunities, accounts, and customer relationships](/agentkit/connectors/salesforce/) [OAuth 2.0](/agentkit/connectors/salesforce/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/salesloft.svg)](/agentkit/connectors/salesloft/) [Salesloft connector](/agentkit/connectors/salesloft/) [Connect with Salesloft to manage people, cadences, accounts, activities, emails, calls, and notes](/agentkit/connectors/salesloft/) [OAuth 2.0](/agentkit/connectors/salesloft/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sanity.svg)](/agentkit/connectors/sanitymcp/) [Sanity MCP connector](/agentkit/connectors/sanitymcp/) [Connect to Sanity. Manage structured content, documents, datasets, schemas, releases, and media assets for headless CMS workflows.](/agentkit/connectors/sanitymcp/) [OAuth 2.1/DCR](/agentkit/connectors/sanitymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/scrapfly.svg)](/agentkit/connectors/scarpflymcp/) [Scarpfly MCP connector](/agentkit/connectors/scarpflymcp/) [Connect to Scrapfly MCP. Scrape web pages, take screenshots, and control a cloud browser with anti-bot bypass, JS rendering, and proxy support.](/agentkit/connectors/scarpflymcp/) [OAuth 2.1/DCR](/agentkit/connectors/scarpflymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/scholargateway.svg)](/agentkit/connectors/scholargateway/) [Scholar Gateway MCP connector](/agentkit/connectors/scholargateway/) [Connect to Scholar Gateway to search Wiley's peer-reviewed academic literature — 8M+ articles from 2,000+ journals spanning sciences, healthcare...](/agentkit/connectors/scholargateway/) [OAuth2.1/DCR](/agentkit/connectors/scholargateway/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/semaphoreci.svg)](/agentkit/connectors/semaphorecimcp/) [Semaphore CI MCP connector](/agentkit/connectors/semaphorecimcp/) [Semaphore CI is a fast, cloud-native continuous integration and delivery platform that automates building, testing, and deploying software with flexible...](/agentkit/connectors/semaphorecimcp/) [OAuth2.1/DCR](/agentkit/connectors/semaphorecimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/send.svg)](/agentkit/connectors/sendmcp/) [Send MCP connector](/agentkit/connectors/sendmcp/) [Connect to Send to create, edit, and share Claude-generated documents as polished web pages with engagement tracking, custom domains, and team asset...](/agentkit/connectors/sendmcp/) [OAuth2.1/DCR](/agentkit/connectors/sendmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sendgrid.svg)](/agentkit/connectors/sendgrid/) [SendGrid connector](/agentkit/connectors/sendgrid/) [Connect to Twilio SendGrid to send transactional and marketing email at scale, manage templates, contacts, lists, segments, and single sends, verify...](/agentkit/connectors/sendgrid/) [Bearer Token](/agentkit/connectors/sendgrid/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sentry.svg)](/agentkit/connectors/sentrymcp/) [Sentry MCP connector](/agentkit/connectors/sentrymcp/) [Connect to Sentry MCP server to monitor errors, investigate issues, manage projects, and analyze performance directly from your AI workflows.](/agentkit/connectors/sentrymcp/) [OAuth 2.1/DCR](/agentkit/connectors/sentrymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/servicenow.svg)](/agentkit/connectors/servicenow/) [ServiceNow connector](/agentkit/connectors/servicenow/) [Connect to ServiceNow. Manage incidents, service requests, CMDB, and IT service management workflows](/agentkit/connectors/servicenow/) [OAuth 2.0](/agentkit/connectors/servicenow/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sharepoint.svg)](/agentkit/connectors/sharepoint/) [SharePoint connector](/agentkit/connectors/sharepoint/) [Connect to SharePoint. Manage sites, documents, lists, and collaborative content](/agentkit/connectors/sharepoint/) [OAuth 2.0](/agentkit/connectors/sharepoint/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/signwell.svg)](/agentkit/connectors/signwell/) [SignWell connector](/agentkit/connectors/signwell/) [SignWell is an e-signature platform for sending, signing, and managing documents. Connect to create and send documents for signature, manage templates...](/agentkit/connectors/signwell/) [API Key](/agentkit/connectors/signwell/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/slack.svg)](/agentkit/connectors/slack/) [Slack connector](/agentkit/connectors/slack/) [Connect to Slack workspace. Send Messages as Bots or on behalf of users](/agentkit/connectors/slack/) [OAuth 2.0](/agentkit/connectors/slack/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/slack.svg)](/agentkit/connectors/slackmcp/) [Slack MCP connector](/agentkit/connectors/slackmcp/) [Connect to Slack MCP. Send and read messages, search channels and users, manage canvases, and react to messages across your Slack workspace.](/agentkit/connectors/slackmcp/) [OAuth 2.1](/agentkit/connectors/slackmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sleekplan.svg)](/agentkit/connectors/sleekplanmcp/) [Sleekplan MCP connector](/agentkit/connectors/sleekplanmcp/) [Sleekplan is a customer feedback, feature request, and roadmap management platform.](/agentkit/connectors/sleekplanmcp/) [OAuth2.1/DCR](/agentkit/connectors/sleekplanmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/slite.svg)](/agentkit/connectors/slitemcp/) [Slite MCP connector](/agentkit/connectors/slitemcp/) [Connect to Slite MCP. Create and manage notes, channels, collections, and comments in Slite from AI workflows.](/agentkit/connectors/slitemcp/) [OAuth 2.1/DCR](/agentkit/connectors/slitemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/snowflake.svg)](/agentkit/connectors/snowflake/) [Snowflake connector](/agentkit/connectors/snowflake/) [Connect to Snowflake to manage and analyze your data warehouse workloads](/agentkit/connectors/snowflake/) [OAuth 2.0](/agentkit/connectors/snowflake/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/snowflake.svg)](/agentkit/connectors/snowflakekeyauth/) [Snowflake Key Pair Auth connector](/agentkit/connectors/snowflakekeyauth/) [Connect to Snowflake via Public Private Key Pair to manage and analyze your data warehouse workloads](/agentkit/connectors/snowflakekeyauth/) [Bearer Token](/agentkit/connectors/snowflakekeyauth/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/splice.svg)](/agentkit/connectors/splicemcp/) [Splice MCP connector](/agentkit/connectors/splicemcp/) [Connect to Splice MCP. Search the Splice sample catalog, create and update multi-track stacks, download audio assets, and generate arrangements from text...](/agentkit/connectors/splicemcp/) [OAuth 2.1/DCR](/agentkit/connectors/splicemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sportradar.svg)](/agentkit/connectors/sportradarmcp/) [Sportradar MCP connector](/agentkit/connectors/sportradarmcp/) [Connect to Sportradar MCP. Browse and search sports data API specs, discover endpoints, check coverage, and access guide pages from your AI workflows.](/agentkit/connectors/sportradarmcp/) [OAuth 2.1/DCR](/agentkit/connectors/sportradarmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/stackai.svg)](/agentkit/connectors/stackaimcp/) [Stack.ai MCP connector](/agentkit/connectors/stackaimcp/) [Connect to Stack AI MCP. Build, run, and manage AI workflow projects, search knowledge bases, list integration providers, and inspect execution traces...](/agentkit/connectors/stackaimcp/) [OAuth 2.1/DCR](/agentkit/connectors/stackaimcp/) [![](https://dac-static.atlassian.com/_static/Statuspage-blue.svg)](/agentkit/connectors/statuspage/) [Statuspage connector](/agentkit/connectors/statuspage/) [Connect to Statuspage. Manage status pages, incidents, components, component groups, subscribers, metrics, and page access permissions.](/agentkit/connectors/statuspage/) [API Key](/agentkit/connectors/statuspage/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/storeleads.svg)](/agentkit/connectors/storeleadsmcp/) [StoreLeads MCP connector](/agentkit/connectors/storeleadsmcp/) [Connect to StoreLeads MCP to discover, search, and analyze e-commerce stores and their technology stack from your AI workflows.](/agentkit/connectors/storeleadsmcp/) [Bearer Token](/agentkit/connectors/storeleadsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/stripe.svg)](/agentkit/connectors/stripe/) [Stripe connector](/agentkit/connectors/stripe/) [Connect to Stripe to manage customers, payments, products, subscriptions, invoices, and financial data.](/agentkit/connectors/stripe/) [Bearer Token](/agentkit/connectors/stripe/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/stripe.svg)](/agentkit/connectors/stripemcp/) [Stripe MCP connector](/agentkit/connectors/stripemcp/) [Connect to Stripe MCP. Manage customers, invoices, subscriptions, refunds, disputes, and payments from your AI workflows.](/agentkit/connectors/stripemcp/) [OAuth 2.1/DCR](/agentkit/connectors/stripemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/supabase.svg)](/agentkit/connectors/supabase/) [Supabase connector](/agentkit/connectors/supabase/) [Connect to the Supabase Management API to manage organizations, projects, database branches, API keys, secrets, custom domains, network restrictions...](/agentkit/connectors/supabase/) [OAuth 2.0](/agentkit/connectors/supabase/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/supadata.svg)](/agentkit/connectors/supadata/) [Supadata connector](/agentkit/connectors/supadata/) [Connect with Supadata to extract transcripts, metadata, and structured content from YouTube, social media, and the web using AI.](/agentkit/connectors/supadata/) [API Key](/agentkit/connectors/supadata/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/supadata.svg)](/agentkit/connectors/supadatamcp/) [Supadata MCP connector](/agentkit/connectors/supadatamcp/) [Connect with Supadata MCP to extract transcripts, metadata, and structured content from YouTube, social media, and the web using AI.](/agentkit/connectors/supadatamcp/) [OAuth 2.1/DCR](/agentkit/connectors/supadatamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/supermetrics.svg)](/agentkit/connectors/supermetricsmcp/) [Supermetrics MCP connector](/agentkit/connectors/supermetricsmcp/) [Connect to Supermetrics MCP to query marketing data, discover data sources, manage campaigns, and run analytics across your connected ad and analytics...](/agentkit/connectors/supermetricsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/supermetricsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/surveymonkey.svg)](/agentkit/connectors/surveymonkeymcp/) [SurveyMonkey MCP connector](/agentkit/connectors/surveymonkeymcp/) [Connect to SurveyMonkey to manage surveys, collect responses, and analyze results. Create and update surveys, manage collectors and contacts, and retrieve...](/agentkit/connectors/surveymonkeymcp/) [OAuth2.1/DCR](/agentkit/connectors/surveymonkeymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/swagger.svg)](/agentkit/connectors/swaggermcp/) [Swagger MCP connector](/agentkit/connectors/swaggermcp/) [Connect to Swagger MCP. Create and manage APIs, developer portals, and documentation in SwaggerHub from AI workflows.](/agentkit/connectors/swaggermcp/) [OAuth 2.1/DCR](/agentkit/connectors/swaggermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sybill.svg)](/agentkit/connectors/sybilmcp/) [Sybill MCP connector](/agentkit/connectors/sybilmcp/) [Connect to Sybill. Access AI-generated summaries of sales calls, deals, accounts, and conversations to accelerate B2B revenue workflows.](/agentkit/connectors/sybilmcp/) [OAuth 2.1/DCR](/agentkit/connectors/sybilmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/synapse.svg)](/agentkit/connectors/synapsemcp/) [Synapse MCP connector](/agentkit/connectors/synapsemcp/) [Connect to the Synapse MCP server (Sage Bionetworks) to explore Synapse entities, annotations, provenance, and project structure, and to search...](/agentkit/connectors/synapsemcp/) [OAuth 2.1/DCR](/agentkit/connectors/synapsemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/synthesize-bio.svg)](/agentkit/connectors/synthesizebiomcp/) [Synthesize Bio MCP connector](/agentkit/connectors/synthesizebiomcp/) [Connect to Synthesize Bio MCP. Run differential gene expression analysis, resolve sample metadata, and retrieve results and raw counts data from your AI...](/agentkit/connectors/synthesizebiomcp/) [OAuth 2.1/DCR](/agentkit/connectors/synthesizebiomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tableau.svg)](/agentkit/connectors/tableau/) [Tableau connector](/agentkit/connectors/tableau/) [Connect to Tableau Cloud or Tableau Server to browse workbooks, views, and data sources, export visualizations, and query underlying data.](/agentkit/connectors/tableau/) [API Key](/agentkit/connectors/tableau/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tactiq.svg)](/agentkit/connectors/tactiqmcp/) [Tactiq MCP connector](/agentkit/connectors/tactiqmcp/) [Tactiq captures and transcribes meetings in real time, turning conversations into AI-generated notes, summaries, and action items.](/agentkit/connectors/tactiqmcp/) [OAuth2.1/DCR](/agentkit/connectors/tactiqmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tally.svg)](/agentkit/connectors/tallymcp/) [Tally MCP connector](/agentkit/connectors/tallymcp/) [Connect to Tally MCP. Create and edit forms, manage submissions, and update styling and logic in your Tally workspace from AI workflows.](/agentkit/connectors/tallymcp/) [OAuth 2.1/DCR](/agentkit/connectors/tallymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tango.svg)](/agentkit/connectors/tangomcp/) [Tango MCP connector](/agentkit/connectors/tangomcp/) [Connect to Tango MCP by makegov to search federal contracts, opportunities, vehicles, organizations, and protests, and pull competitive...](/agentkit/connectors/tangomcp/) [API Key](/agentkit/connectors/tangomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tavily.svg)](/agentkit/connectors/tavilymcp/) [Tavily MCP connector](/agentkit/connectors/tavilymcp/) [Connect to Tavily MCP. Search the web, crawl websites, extract content, map site structure, and run deep research using Tavily's AI-powered search API.](/agentkit/connectors/tavilymcp/) [OAuth 2.1/DCR](/agentkit/connectors/tavilymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/microsoft-teams.svg)](/agentkit/connectors/microsoftteams/) [Teams connector](/agentkit/connectors/microsoftteams/) [Connect to Microsoft Teams. Manage messages, channels, meetings, and team collaboration](/agentkit/connectors/microsoftteams/) [OAuth 2.0](/agentkit/connectors/microsoftteams/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/telnyx.svg)](/agentkit/connectors/telnyxmcp/) [Telnyx MCP connector](/agentkit/connectors/telnyxmcp/) [Telnyx is a communications platform for voice, messaging, and AI. This MCP connector lets AI agents manage phone numbers, send SMS and MMS, place and...](/agentkit/connectors/telnyxmcp/) [OAuth 2.1/DCR](/agentkit/connectors/telnyxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/testdino.svg)](/agentkit/connectors/testidinomcp/) [Testdino MCP connector](/agentkit/connectors/testidinomcp/) [TestDino is a Playwright test reporting and analytics platform that centralizes test data, detects flaky tests, and provides AI-powered debugging via MCP...](/agentkit/connectors/testidinomcp/) [OAuth2.1/DCR](/agentkit/connectors/testidinomcp/) [![]()](/agentkit/connectors/ticktickmcp/) [TickTick MCP connector](/agentkit/connectors/ticktickmcp/) [Connect to TickTick MCP. Manage tasks, projects, habits, and focus sessions in your TickTick account from AI workflows.](/agentkit/connectors/ticktickmcp/) [OAuth 2.1/DCR](/agentkit/connectors/ticktickmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tinyfish.svg)](/agentkit/connectors/tinyfishmcp/) [Tinyfish MCP connector](/agentkit/connectors/tinyfishmcp/) [Connect to Tinyfish MCP. Run browser-based web automations, fetch page content, and search the web using a real cloud Chrome browser.](/agentkit/connectors/tinyfishmcp/) [OAuth 2.1/DCR](/agentkit/connectors/tinyfishmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/todoist.svg)](/agentkit/connectors/todoistmcp/) [Todoist MCP connector](/agentkit/connectors/todoistmcp/) [Connect to Todoist MCP. Manage tasks, projects, sections, labels, filters, goals, and reminders from your AI workflows.](/agentkit/connectors/todoistmcp/) [OAuth 2.1/DCR](/agentkit/connectors/todoistmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/topcounsel.svg)](/agentkit/connectors/topcounselmcp/) [TopCounsel MCP connector](/agentkit/connectors/topcounselmcp/) [Connect to TopCounsel by The L Suite to search, shortlist, and compare peer-vetted outside counsel recommendations grounded in firsthand feedback from...](/agentkit/connectors/topcounselmcp/) [OAuth 2.1/DCR](/agentkit/connectors/topcounselmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/trello_n.svg)](/agentkit/connectors/trello/) [Trello connector](/agentkit/connectors/trello/) [Connect to Trello. Manage boards, cards, lists, and team collaboration workflows](/agentkit/connectors/trello/) [OAuth 1.0a](/agentkit/connectors/trello/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/twelvedata.svg)](/agentkit/connectors/twelvedatamcp/) [Twelve Data MCP connector](/agentkit/connectors/twelvedatamcp/) [Connect to Twelve Data MCP for real-time and historical financial market data, including stock, forex, crypto, and ETF prices, technical indicators...](/agentkit/connectors/twelvedatamcp/) [OAuth 2.1/DCR](/agentkit/connectors/twelvedatamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/twilio.svg)](/agentkit/connectors/twilio/) [Twilio connector](/agentkit/connectors/twilio/) [Connect to Twilio to send SMS/MMS messages, make voice calls, verify phone numbers with OTP, manage phone numbers, and access usage records.](/agentkit/connectors/twilio/) [Basic Auth](/agentkit/connectors/twilio/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/X.svg)](/agentkit/connectors/twitter/) [Twitter / X connector](/agentkit/connectors/twitter/) [Connect to Twitter. Read and write Tweets, read users, manage follows, bookmarks, etc.](/agentkit/connectors/twitter/) [Bearer Token](/agentkit/connectors/twitter/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/typeform.svg)](/agentkit/connectors/typeformmcp/) [Typeform MCP connector](/agentkit/connectors/typeformmcp/) [Connect to Typeform MCP to create and manage forms, read responses, and manage workspaces, contacts, and webhooks directly from your AI workflows.](/agentkit/connectors/typeformmcp/) [OAuth 2.1/DCR](/agentkit/connectors/typeformmcp/) [![](https://framerusercontent.com/images/Pl7PUhW6GIt6eumE6hy3eKACaA.png)](/agentkit/connectors/upstreammcp/) [Upstream MCP connector](/agentkit/connectors/upstreammcp/) [Connect to Upstream MCP to access AI-assistant tools and workflows, including inbox management, directly from your AI workflows.](/agentkit/connectors/upstreammcp/) [Bearer Token](/agentkit/connectors/upstreammcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/v0.svg)](/agentkit/connectors/v0mcp/) [v0 MCP connector](/agentkit/connectors/v0mcp/) [Connect to v0 by Vercel to generate and iterate on web app UIs from natural language. Create chats, send follow-up messages, and inspect v0 Platform chats...](/agentkit/connectors/v0mcp/) [Bearer Token](/agentkit/connectors/v0mcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/vapi.svg)](/agentkit/connectors/vapimcp/) [Vapi MCP connector](/agentkit/connectors/vapimcp/) [Vapi is an AI-powered voice platform for building, testing, and deploying voice AI agents. This MCP connector enables AI agents to manage Vapi assistants...](/agentkit/connectors/vapimcp/) [Bearer Token](/agentkit/connectors/vapimcp/) [![](https://raw.githubusercontent.com/simple-icons/simple-icons/develop/icons/vercel.svg)](/agentkit/connectors/vercel/) [Vercel connector](/agentkit/connectors/vercel/) [Connect to Vercel. Access user profile, teams, projects, deployments, and environment settings.](/agentkit/connectors/vercel/) [OAuth 2.0](/agentkit/connectors/vercel/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/vercel.svg)](/agentkit/connectors/vercelmcp/) [Vercel MCP connector](/agentkit/connectors/vercelmcp/) [Connect to Vercel MCP to manage deployments, projects, domains, environment variables, and team resources directly from your AI workflows.](/agentkit/connectors/vercelmcp/) [OAuth 2.1](/agentkit/connectors/vercelmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/vibeprospecting.svg)](/agentkit/connectors/vibeprospectingmcp/) [Vibe Prospecting MCP connector](/agentkit/connectors/vibeprospectingmcp/) [Connect to Vibe Prospecting by Explorium to build B2B lead lists, research companies and prospects, enrich contacts, and personalize outreach from your AI...](/agentkit/connectors/vibeprospectingmcp/) [OAuth 2.1/DCR](/agentkit/connectors/vibeprospectingmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/vimeo.svg)](/agentkit/connectors/vimeo/) [Vimeo connector](/agentkit/connectors/vimeo/) [Connect to Vimeo API v3.4. Upload and manage videos, organize content into showcases and folders, manage channels, handle comments, likes, and webhooks.](/agentkit/connectors/vimeo/) [OAuth 2.0](/agentkit/connectors/vimeo/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/webflow.svg)](/agentkit/connectors/webflowmcp/) [Webflow MCP connector](/agentkit/connectors/webflowmcp/) [Connect to Webflow. Build and manage websites, pages, components, styles, assets, CMS collections, and site settings through the Webflow Designer and Data...](/agentkit/connectors/webflowmcp/) [OAuth 2.1/DCR](/agentkit/connectors/webflowmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/whimsical.svg)](/agentkit/connectors/whimsicalmcp/) [Whimsical MCP connector](/agentkit/connectors/whimsicalmcp/) [Connect to Whimsical MCP. Create and edit flowcharts, mind maps, wireframes, and docs, and manage boards, comments, and workspaces from your AI workflows.](/agentkit/connectors/whimsicalmcp/) [OAuth 2.1/DCR](/agentkit/connectors/whimsicalmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/whop.svg)](/agentkit/connectors/whopmcp/) [Whop MCP connector](/agentkit/connectors/whopmcp/) [Whop is a platform for selling digital products, memberships, and communities.](/agentkit/connectors/whopmcp/) [OAuth2.1/DCR](/agentkit/connectors/whopmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/wix.svg)](/agentkit/connectors/wixmcp/) [Wix MCP connector](/agentkit/connectors/wixmcp/) [Connect to Wix MCP. Build and manage Wix sites, call REST APIs, search documentation, upload media, and suggest domains from your AI workflows.](/agentkit/connectors/wixmcp/) [OAuth 2.1/DCR](/agentkit/connectors/wixmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/xero.svg)](/agentkit/connectors/xero/) [Xero connector](/agentkit/connectors/xero/) [Connect to Xero. Manage accounting, invoices, contacts, payments, bank transactions, and financial workflows](/agentkit/connectors/xero/) [OAuth 2.0](/agentkit/connectors/xero/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/you.svg)](/agentkit/connectors/youmcp/) [You.com MCP connector](/agentkit/connectors/youmcp/) [Connect to You.com MCP. Search the web, research topics with cited sources, and extract full page content using You.com's AI-powered search and research...](/agentkit/connectors/youmcp/) [Bearer Token](/agentkit/connectors/youmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/youtube.svg)](/agentkit/connectors/youtube/) [YouTube connector](/agentkit/connectors/youtube/) [Connect to YouTube to access channel details, analytics, and upload or manage videos via OAuth 2.0](/agentkit/connectors/youtube/) [OAuth 2.0](/agentkit/connectors/youtube/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zapier.svg)](/agentkit/connectors/zapiermcp/) [Zapier MCP connector](/agentkit/connectors/zapiermcp/) [Connect to Zapier MCP to automate workflows and integrate with thousands of apps directly from your AI agent.](/agentkit/connectors/zapiermcp/) [OAuth 2.1/DCR](/agentkit/connectors/zapiermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zendesk.svg)](/agentkit/connectors/zendeskoauth/) [Zendesk (OAUTH) connector](/agentkit/connectors/zendeskoauth/) [Connect to Zendesk. Manage customer support tickets, users, organizations, and help desk operations](/agentkit/connectors/zendeskoauth/) [OAuth 2.0](/agentkit/connectors/zendeskoauth/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zendesk.svg)](/agentkit/connectors/zendesk/) [Zendesk connector](/agentkit/connectors/zendesk/) [Connect to Zendesk. Manage customer support tickets, users, organizations, and help desk operations](/agentkit/connectors/zendesk/) [API KEY](/agentkit/connectors/zendesk/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zenrows.svg)](/agentkit/connectors/zenrowsmcp/) [ZenRows MCP connector](/agentkit/connectors/zenrowsmcp/) [Connect to ZenRows MCP. Scrape any webpage with anti-bot bypass, render JavaScript-heavy sites, and automate browsers through ZenRows' cloud...](/agentkit/connectors/zenrowsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/zenrowsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zoho_crm.svg)](/agentkit/connectors/zohocrm/) [Zoho CRM connector](/agentkit/connectors/zohocrm/) [Connect to Zoho CRM. Manage leads, contacts, accounts, deals, tasks, and other sales activities.](/agentkit/connectors/zohocrm/) [OAuth 2.0](/agentkit/connectors/zohocrm/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zoom.svg)](/agentkit/connectors/zoom/) [Zoom connector](/agentkit/connectors/zoom/) [Connect to Zoom. Schedule meetings, manage recordings, and handle video conferencing workflows](/agentkit/connectors/zoom/) [OAuth 2.0](/agentkit/connectors/zoom/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zoominfo.svg)](/agentkit/connectors/zoominfo/) [ZoomInfo connector](/agentkit/connectors/zoominfo/) [Connect to ZoomInfo to search and enrich B2B contact and company data, access intent signals, discover technographic insights, and manage GTM Studio...](/agentkit/connectors/zoominfo/) [OAuth 2.0](/agentkit/connectors/zoominfo/) ## Tools ## Accounting & Finance [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/carta.svg)](/agentkit/connectors/cartamcp/) [Carta MCP connector](/agentkit/connectors/cartamcp/) [Connect to Carta. Manage equity cap tables, fund administration, company accounts, and ownership data for venture-backed companies.](/agentkit/connectors/cartamcp/) [OAuth 2.1/DCR](/agentkit/connectors/cartamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/deel.svg)](/agentkit/connectors/deelmcp/) [Deel MCP connector](/agentkit/connectors/deelmcp/) [Global HR and payroll platform for hiring, paying, and managing international employees and contractors with built-in compliance.](/agentkit/connectors/deelmcp/) [OAuth2.1/DCR](/agentkit/connectors/deelmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/digits.svg)](/agentkit/connectors/digitsmcp/) [Digits MCP connector](/agentkit/connectors/digitsmcp/) [Digits is an AI-powered business finance platform. This MCP connector gives AI agents read-only access to your Digits data — transactions, financial...](/agentkit/connectors/digitsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/digitsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dynamo.svg)](/agentkit/connectors/dynamo/) [Dynamo Software connector](/agentkit/connectors/dynamo/) [Connect to Dynamo Software API to access investment management, CRM, and reporting data.](/agentkit/connectors/dynamo/) [Bearer Token](/agentkit/connectors/dynamo/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/eodhd.svg)](/agentkit/connectors/eodhdmcp/) [EODHD MCP connector](/agentkit/connectors/eodhdmcp/) [EODHD (End of Day Historical Data) provides comprehensive financial market data including end-of-day stock prices, historical OHLCV data, fundamentals...](/agentkit/connectors/eodhdmcp/) [OAuth 2.1/DCR](/agentkit/connectors/eodhdmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/eracontext.svg)](/agentkit/connectors/eracontextmcp/) [Era Context MCP connector](/agentkit/connectors/eracontextmcp/) [Connect to Era Context MCP. Access personal finance data including transactions, accounts, spending insights, and AI-powered financial knowledge from Era.](/agentkit/connectors/eracontextmcp/) [OAuth 2.1/DCR](/agentkit/connectors/eracontextmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/financialdatasets.svg)](/agentkit/connectors/financialdatasetsmcp/) [Financial Datasets MCP connector](/agentkit/connectors/financialdatasetsmcp/) [Financial Datasets provides an MCP interface to financial data APIs covering stock prices, financial statements, earnings, insider trades, and...](/agentkit/connectors/financialdatasetsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/financialdatasetsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fiscalai.svg)](/agentkit/connectors/fiscalaimcp/) [FiscalAI MCP connector](/agentkit/connectors/fiscalaimcp/) [Connect to FiscalAI MCP. Access financial data for public companies including SEC filings, earnings, stock prices, financial ratios, and company profiles.](/agentkit/connectors/fiscalaimcp/) [OAuth 2.1/DCR](/agentkit/connectors/fiscalaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gocardless.svg)](/agentkit/connectors/gocardlessmcp/) [GoCardless MCP connector](/agentkit/connectors/gocardlessmcp/) [Connect to GoCardless MCP. Retrieve and list customers, mandates, payments, payouts, refunds, and subscriptions, and explore integration options from your...](/agentkit/connectors/gocardlessmcp/) [OAuth 2.1/DCR](/agentkit/connectors/gocardlessmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gusto.svg)](/agentkit/connectors/gustomcp/) [Gusto MCP connector](/agentkit/connectors/gustomcp/) [Connect to Gusto MCP. Manage employees, contractors, payroll, departments, and company data from your AI workflows.](/agentkit/connectors/gustomcp/) [OAuth 2.1/DCR](/agentkit/connectors/gustomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lunarcrush.svg)](/agentkit/connectors/lunarcrushmcp/) [Lunarcrush MCP connector](/agentkit/connectors/lunarcrushmcp/) [Connect to LunarCrush MCP. Access social intelligence, sentiment analytics, and market data for crypto assets from your AI workflows.](/agentkit/connectors/lunarcrushmcp/) [OAuth 2.1/DCR](/agentkit/connectors/lunarcrushmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mercury.svg)](/agentkit/connectors/mercurymcp/) [Mercury MCP connector](/agentkit/connectors/mercurymcp/) [Connect to Mercury. Access accounts, transactions, recipients, invoices, treasury, webhooks, and approval requests for startup banking workflows.](/agentkit/connectors/mercurymcp/) [OAuth 2.1/DCR](/agentkit/connectors/mercurymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/privacy.svg)](/agentkit/connectors/privacymcp/) [Privacy MCP connector](/agentkit/connectors/privacymcp/) [Connect to Privacy MCP. Create and manage virtual cards, set spend limits, pause or close cards, and review transactions from your AI workflows.](/agentkit/connectors/privacymcp/) [OAuth 2.1/DCR](/agentkit/connectors/privacymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/Quickbooks.svg)](/agentkit/connectors/quickbooks/) [QuickBooks connector](/agentkit/connectors/quickbooks/) [Connect to QuickBooks Online. Manage customers, vendors, invoices, bills, payments, and financial reports.](/agentkit/connectors/quickbooks/) [OAuth 2.0](/agentkit/connectors/quickbooks/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/stripe.svg)](/agentkit/connectors/stripe/) [Stripe connector](/agentkit/connectors/stripe/) [Connect to Stripe to manage customers, payments, products, subscriptions, invoices, and financial data.](/agentkit/connectors/stripe/) [Bearer Token](/agentkit/connectors/stripe/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/stripe.svg)](/agentkit/connectors/stripemcp/) [Stripe MCP connector](/agentkit/connectors/stripemcp/) [Connect to Stripe MCP. Manage customers, invoices, subscriptions, refunds, disputes, and payments from your AI workflows.](/agentkit/connectors/stripemcp/) [OAuth 2.1/DCR](/agentkit/connectors/stripemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/twelvedata.svg)](/agentkit/connectors/twelvedatamcp/) [Twelve Data MCP connector](/agentkit/connectors/twelvedatamcp/) [Connect to Twelve Data MCP for real-time and historical financial market data, including stock, forex, crypto, and ETF prices, technical indicators...](/agentkit/connectors/twelvedatamcp/) [OAuth 2.1/DCR](/agentkit/connectors/twelvedatamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/xero.svg)](/agentkit/connectors/xero/) [Xero connector](/agentkit/connectors/xero/) [Connect to Xero. Manage accounting, invoices, contacts, payments, bank transactions, and financial workflows](/agentkit/connectors/xero/) [OAuth 2.0](/agentkit/connectors/xero/) ## AI [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/adobe.svg)](/agentkit/connectors/adobemarketingagentmcp/) [Adobe Marketing Agent MCP connector](/agentkit/connectors/adobemarketingagentmcp/) [Connect to Adobe Marketing Cloud. Manage campaigns, analytics, and journeys using a natural-language AI assistant.](/agentkit/connectors/adobemarketingagentmcp/) [OAuth 2.1/DCR](/agentkit/connectors/adobemarketingagentmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/affinda.svg)](/agentkit/connectors/affindamcp/) [Affinda MCP connector](/agentkit/connectors/affindamcp/) [AI-powered document processing platform that extracts, validates, and integrates structured data from invoices, resumes, contracts, and custom document...](/agentkit/connectors/affindamcp/) [OAuth2.1/DCR](/agentkit/connectors/affindamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/agentmail.svg)](/agentkit/connectors/agentmailmcp/) [Agentmail MCP connector](/agentkit/connectors/agentmailmcp/) [Connect to Agentmail MCP. Manage inboxes, send and receive email, handle drafts, threads, and attachments from your AI workflows.](/agentkit/connectors/agentmailmcp/) [OAuth 2.1/DCR](/agentkit/connectors/agentmailmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airops.svg)](/agentkit/connectors/airopsmcp/) [Airops MCP connector](/agentkit/connectors/airopsmcp/) [Connect to AirOps MCP. Manage brand kits, run AI-powered analytics, track AEO citations, and automate content workflows from your AI agents.](/agentkit/connectors/airopsmcp/) [API Key](/agentkit/connectors/airopsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airparser.svg)](/agentkit/connectors/airparsermcp/) [Airparser MCP connector](/agentkit/connectors/airparsermcp/) [AI-powered document parser that extracts structured data from PDFs, emails, and other documents.](/agentkit/connectors/airparsermcp/) [OAuth2.1/DCR](/agentkit/connectors/airparsermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/alphaxiv.svg)](/agentkit/connectors/alphaxivmcp/) [AlphaXiv MCP connector](/agentkit/connectors/alphaxivmcp/) [Connect to AlphaXiv MCP to search and retrieve arXiv research papers, abstracts, authors, and citations from your AI workflows.](/agentkit/connectors/alphaxivmcp/) [OAuth 2.1/DCR](/agentkit/connectors/alphaxivmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/anakin.svg)](/agentkit/connectors/anakinmcp/) [Anakin MCP connector](/agentkit/connectors/anakinmcp/) [Anakin is an AI platform and marketplace that lets you build, deploy, and access a wide range of AI tools and automated workflows. This MCP connector...](/agentkit/connectors/anakinmcp/) [OAuth2.1/DCR](/agentkit/connectors/anakinmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/anchorbrowser.svg)](/agentkit/connectors/anchorbrowsermcp/) [Anchor Browser MCP connector](/agentkit/connectors/anchorbrowsermcp/) [Connect to Anchor Browser MCP to run cloud browser automation, control live browser sessions, extract web data, and let AI agents browse and act on the...](/agentkit/connectors/anchorbrowsermcp/) [OAuth 2.1/DCR](/agentkit/connectors/anchorbrowsermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/apify.svg)](/agentkit/connectors/apifymcp/) [Apify MCP connector](/agentkit/connectors/apifymcp/) [Connect to Apify MCP to run web scraping, browser automation, and data extraction Actors directly from your AI workflows.](/agentkit/connectors/apifymcp/) [Bearer Token](/agentkit/connectors/apifymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/attention.svg)](/agentkit/connectors/attention/) [Attention connector](/agentkit/connectors/attention/) [Connect to Attention for AI insights, conversations, teams, and workflows](/agentkit/connectors/attention/) [API Key](/agentkit/connectors/attention/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/biorendermcp.svg)](/agentkit/connectors/biorendermcp/) [Bio Render MCP connector](/agentkit/connectors/biorendermcp/) [Connect to BioRender MCP. Search BioRender's scientific icon and figure template libraries to build publication-ready biological illustrations.](/agentkit/connectors/biorendermcp/) [OAuth 2.1/DCR](/agentkit/connectors/biorendermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bitquery.svg)](/agentkit/connectors/bitquerymcp/) [Bitquery MCP connector](/agentkit/connectors/bitquerymcp/) [Connect to Bitquery MCP. Query on-chain DEX trading data, token prices, OHLCV series, trader profiles, and trending tokens across multiple blockchains...](/agentkit/connectors/bitquerymcp/) [OAuth 2.1/DCR](/agentkit/connectors/bitquerymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/brevo.svg)](/agentkit/connectors/brevomcp/) [Brevo MCP connector](/agentkit/connectors/brevomcp/) [Connect to Brevo MCP. Manage email and SMS campaigns, transactional emails, contacts, lists, automations, and loyalty programs from your AI workflows.](/agentkit/connectors/brevomcp/) [OAuth 2.1/DCR](/agentkit/connectors/brevomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bugsnag.svg)](/agentkit/connectors/bugsnagmcp/) [Bugsnag MCP connector](/agentkit/connectors/bugsnagmcp/) [Connect to Bugsnag MCP. Monitor errors, releases, traces, and span groups across your projects from your AI workflows.](/agentkit/connectors/bugsnagmcp/) [OAuth 2.1/DCR](/agentkit/connectors/bugsnagmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/buildkite.svg)](/agentkit/connectors/buildkitemcp/) [Buildkite MCP connector](/agentkit/connectors/buildkitemcp/) [Connect to Buildkite MCP. Manage CI/CD pipelines, builds, agents, clusters, and test suites from your AI workflows.](/agentkit/connectors/buildkitemcp/) [OAuth 2.1/DCR](/agentkit/connectors/buildkitemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/cal.svg)](/agentkit/connectors/calmcp/) [Cal MCP connector](/agentkit/connectors/calmcp/) [Connect to Cal MCP. Manage bookings, event types, schedules, and availability from your AI workflows.](/agentkit/connectors/calmcp/) [OAuth 2.1/DCR](/agentkit/connectors/calmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/candid.svg)](/agentkit/connectors/candidmcp/) [Candid MCP connector](/agentkit/connectors/candidmcp/) [Connect to Candid MCP. Search nonprofit organizations, explore philanthropic data, and classify social sector activities using Candid's knowledge base.](/agentkit/connectors/candidmcp/) [OAuth 2.1/DCR](/agentkit/connectors/candidmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/carbone.svg)](/agentkit/connectors/carboneiomcp/) [Carbone.io MCP connector](/agentkit/connectors/carboneiomcp/) [Connect to Carbone.io MCP. Upload templates, render documents by merging templates with JSON data, convert between 100+ formats, and manage template...](/agentkit/connectors/carboneiomcp/) [Bearer Token](/agentkit/connectors/carboneiomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/chorus.svg)](/agentkit/connectors/chorus/) [Chorus connector](/agentkit/connectors/chorus/) [Connect to Chorus.ai to sync calls, transcripts, conversation intelligence, and analytics.](/agentkit/connectors/chorus/) [Basic Auth](/agentkit/connectors/chorus/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clari.svg)](/agentkit/connectors/clari_copilot/) [Clari Copilot connector](/agentkit/connectors/clari_copilot/) [Connect to Clari Copilot for sales call transcripts, analytics, call data, and insights.](/agentkit/connectors/clari_copilot/) [API Key](/agentkit/connectors/clari_copilot/) [![](https://platform.cognee.ai/icon.svg?icon.3c7f72a5.svg)](/agentkit/connectors/cognee/) [Cognee connector](/agentkit/connectors/cognee/) [Connect to Cognee, an AI memory engine for agents. Remember data into a knowledge graph, recall it with semantic search, improve stored memory, and forget...](/agentkit/connectors/cognee/) [API Key](/agentkit/connectors/cognee/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/coinmarketcap.svg)](/agentkit/connectors/coinmarketcapmcp/) [CoinMarketCap MCP connector](/agentkit/connectors/coinmarketcapmcp/) [Connect to CoinMarketCap MCP. Access real-time crypto quotes, market metrics, technical analysis, trending narratives, and news from your AI workflows.](/agentkit/connectors/coinmarketcapmcp/) [OAuth 2.1/DCR](/agentkit/connectors/coinmarketcapmcp/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/context7.svg)](/agentkit/connectors/context7mcp/) [Context7 MCP connector](/agentkit/connectors/context7mcp/) [Connect to Context7 MCP to fetch up-to-date, version-specific library documentation and code examples directly from the source.](/agentkit/connectors/context7mcp/) [API Key](/agentkit/connectors/context7mcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/conversiontools.svg)](/agentkit/connectors/conversiontoolsmcp/) [Conversion Tools MCP connector](/agentkit/connectors/conversiontoolsmcp/) [Connect to Conversion Tools MCP. Convert files between 140+ formats including documents, images, audio, video, and data files from your AI workflows.](/agentkit/connectors/conversiontoolsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/conversiontoolsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dartai.svg)](/agentkit/connectors/dartaimcp/) [Dart AI MCP connector](/agentkit/connectors/dartaimcp/) [AI-native project management tool for task and document management with deep AI integration.](/agentkit/connectors/dartaimcp/) [OAuth2.1/DCR](/agentkit/connectors/dartaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dataforseo.svg)](/agentkit/connectors/dataforseomcp/) [Dataforseo MCP connector](/agentkit/connectors/dataforseomcp/) [Connect to DataForSEO. Access real-time SEO data including SERP results, keyword analytics, backlinks analysis, domain technologies, and AI visibility...](/agentkit/connectors/dataforseomcp/) [OAuth 2.1/DCR](/agentkit/connectors/dataforseomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/deepgram.svg)](/agentkit/connectors/deepgrammcp/) [Deepgram MCP connector](/agentkit/connectors/deepgrammcp/) [Connect to Deepgram MCP. Transcribe audio, generate speech, and manage transcription projects using Deepgram's AI-powered speech recognition API.](/agentkit/connectors/deepgrammcp/) [OAuth 2.1/DCR](/agentkit/connectors/deepgrammcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/descript.svg)](/agentkit/connectors/descriptmcp/) [Descript MCP connector](/agentkit/connectors/descriptmcp/) [Connect to Descript MCP. Import media, export transcripts, publish projects, run AI editing agents, and manage jobs from your AI workflows.](/agentkit/connectors/descriptmcp/) [OAuth 2.1/DCR](/agentkit/connectors/descriptmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/devin.svg)](/agentkit/connectors/devinmcp/) [Devin MCP connector](/agentkit/connectors/devinmcp/) [Connect to Devin MCP. Create and manage AI coding sessions, interact with Devin agents, manage playbooks and schedules, and browse repository wikis from...](/agentkit/connectors/devinmcp/) [Bearer Token](/agentkit/connectors/devinmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/digits.svg)](/agentkit/connectors/digitsmcp/) [Digits MCP connector](/agentkit/connectors/digitsmcp/) [Digits is an AI-powered business finance platform. This MCP connector gives AI agents read-only access to your Digits data — transactions, financial...](/agentkit/connectors/digitsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/digitsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dovetail.svg)](/agentkit/connectors/dovetailmcp/) [Dovetail MCP connector](/agentkit/connectors/dovetailmcp/) [Connect to Dovetail, the AI-native UX research platform. Access projects, insights, and data from your AI workflows.](/agentkit/connectors/dovetailmcp/) [Bearer Token](/agentkit/connectors/dovetailmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/eden.svg)](/agentkit/connectors/edenmcp/) [Eden MCP connector](/agentkit/connectors/edenmcp/) [Eden is an AI-powered content creation platform that discovers viral trends across 3M+ social media posts and helps creators generate content in their...](/agentkit/connectors/edenmcp/) [OAuth2.1/DCR](/agentkit/connectors/edenmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/eodhd.svg)](/agentkit/connectors/eodhdmcp/) [EODHD MCP connector](/agentkit/connectors/eodhdmcp/) [EODHD (End of Day Historical Data) provides comprehensive financial market data including end-of-day stock prices, historical OHLCV data, fundamentals...](/agentkit/connectors/eodhdmcp/) [OAuth 2.1/DCR](/agentkit/connectors/eodhdmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/eracontext.svg)](/agentkit/connectors/eracontextmcp/) [Era Context MCP connector](/agentkit/connectors/eracontextmcp/) [Connect to Era Context MCP. Access personal finance data including transactions, accounts, spending insights, and AI-powered financial knowledge from Era.](/agentkit/connectors/eracontextmcp/) [OAuth 2.1/DCR](/agentkit/connectors/eracontextmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/exa.svg)](/agentkit/connectors/exa/) [Exa connector](/agentkit/connectors/exa/) [Connect to Exa to perform AI-powered semantic web search, crawl websites for structured content, get natural language answers from the web, run in-depth...](/agentkit/connectors/exa/) [API Key](/agentkit/connectors/exa/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/exa.svg)](/agentkit/connectors/examcp/) [Exa MCP connector](/agentkit/connectors/examcp/) [Connect to Exa MCP to perform AI-powered semantic web search, crawl websites for structured content, get natural language answers from the web, and run...](/agentkit/connectors/examcp/) [API Key](/agentkit/connectors/examcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fathom.svg)](/agentkit/connectors/fathom/) [Fathom connector](/agentkit/connectors/fathom/) [Connect to Fathom AI meeting assistant. Record, transcribe, and summarize meetings with AI-powered insights](/agentkit/connectors/fathom/) [API Key](/agentkit/connectors/fathom/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fathom.svg)](/agentkit/connectors/fathommcp/) [Fathom MCP connector](/agentkit/connectors/fathommcp/) [Connect to Fathom MCP to access AI meeting notes, summaries, transcripts, and recordings from your AI workflows.](/agentkit/connectors/fathommcp/) [OAuth 2.1/DCR](/agentkit/connectors/fathommcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/firecrawl.svg)](/agentkit/connectors/firecrawlmcp/) [Firecrawl MCP connector](/agentkit/connectors/firecrawlmcp/) [Connect to Firecrawl MCP. Scrape, crawl, search, extract structured data, and monitor websites using Firecrawl's AI-powered web scraping API.](/agentkit/connectors/firecrawlmcp/) [Bearer Token](/agentkit/connectors/firecrawlmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fiscalai.svg)](/agentkit/connectors/fiscalaimcp/) [FiscalAI MCP connector](/agentkit/connectors/fiscalaimcp/) [Connect to FiscalAI MCP. Access financial data for public companies including SEC filings, earnings, stock prices, financial ratios, and company profiles.](/agentkit/connectors/fiscalaimcp/) [OAuth 2.1/DCR](/agentkit/connectors/fiscalaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/flux.svg)](/agentkit/connectors/fluxmcp/) [Flux MCP connector](/agentkit/connectors/fluxmcp/) [Flux by Black Forest Labs provides state-of-the-art AI image generation via the FLUX.1 family of models. Generate high-quality images from text prompts...](/agentkit/connectors/fluxmcp/) [OAuth 2.1/DCR](/agentkit/connectors/fluxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gocardless.svg)](/agentkit/connectors/gocardlessmcp/) [GoCardless MCP connector](/agentkit/connectors/gocardlessmcp/) [Connect to GoCardless MCP. Retrieve and list customers, mandates, payments, payouts, refunds, and subscriptions, and explore integration options from your...](/agentkit/connectors/gocardlessmcp/) [OAuth 2.1/DCR](/agentkit/connectors/gocardlessmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gong.svg)](/agentkit/connectors/gong/) [Gong connector](/agentkit/connectors/gong/) [Connect with Gong to sync calls, transcripts, insights, coaching and CRM activity](/agentkit/connectors/gong/) [OAuth 2.0](/agentkit/connectors/gong/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gong.svg)](/agentkit/connectors/gongmcp/) [Gong MCP connector](/agentkit/connectors/gongmcp/) [Connect with Gong MCP to access calls, transcripts, insights, coaching, and sales engagement data via the Model Context Protocol](/agentkit/connectors/gongmcp/) [OAuth2.1](/agentkit/connectors/gongmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/grain.svg)](/agentkit/connectors/grainmcp/) [Grain MCP connector](/agentkit/connectors/grainmcp/) [Grain is a meeting recording and intelligence platform. Use this connector to search and retrieve meeting recordings, transcripts, notes, action items...](/agentkit/connectors/grainmcp/) [OAuth 2.1/DCR](/agentkit/connectors/grainmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/granola.svg)](/agentkit/connectors/granola/) [Granola connector](/agentkit/connectors/granola/) [Connect to Granola to access AI-generated meeting notes, summaries, transcripts, and attendee data from your workspace. Granola automatically records and...](/agentkit/connectors/granola/) [Bearer Token](/agentkit/connectors/granola/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/granola.svg)](/agentkit/connectors/granolamcp/) [Granola MCP connector](/agentkit/connectors/granolamcp/) [Connect to Granola MCP using OAuth 2.1 with MCP discovery and dynamic client registration.](/agentkit/connectors/granolamcp/) [OAuth 2.1/DCR](/agentkit/connectors/granolamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/greptile.svg)](/agentkit/connectors/greptilmcp/) [Greptile MCP connector](/agentkit/connectors/greptilmcp/) [AI-powered code search and understanding API that indexes GitHub and GitLab repositories, enabling natural language queries over codebases.](/agentkit/connectors/greptilmcp/) [OAuth2.1/DCR](/agentkit/connectors/greptilmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/happyscribe.svg)](/agentkit/connectors/happyscribemcp/) [HappyScribe connector](/agentkit/connectors/happyscribemcp/) [HappyScribe is an AI-powered transcription and translation service. Connect your HappyScribe account to search transcripts, generate meeting summaries...](/agentkit/connectors/happyscribemcp/) [OAuth2.1/DCR](/agentkit/connectors/happyscribemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/hex.svg)](/agentkit/connectors/hexmcp/) [Hex MCP connector](/agentkit/connectors/hexmcp/) [Connect to Hex MCP. Create and continue data analysis threads, search projects, and query your data using natural language from your AI workflows.](/agentkit/connectors/hexmcp/) [OAuth 2.1/DCR](/agentkit/connectors/hexmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/huggingface.svg)](/agentkit/connectors/huggingfacemcp/) [Hugging face MCP connector](/agentkit/connectors/huggingfacemcp/) [Connect to Hugging Face MCP. Search and manage models, datasets, spaces, and collections on the Hugging Face Hub.](/agentkit/connectors/huggingfacemcp/) [OAuth 2.1/DCR](/agentkit/connectors/huggingfacemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/igpt.svg)](/agentkit/connectors/igptmcp/) [IGPT MCP connector](/agentkit/connectors/igptmcp/) [IGPT is an AI assistant platform that exposes its capabilities via an MCP server, enabling agents to interact with AI-powered tools and workflows.](/agentkit/connectors/igptmcp/) [OAuth2.1/DCR](/agentkit/connectors/igptmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jam.svg)](/agentkit/connectors/jammcp/) [Jam MCP connector](/agentkit/connectors/jammcp/) [Connect to Jam MCP. Access bug reports, console logs, network requests, user events, and video transcripts from your AI workflows.](/agentkit/connectors/jammcp/) [OAuth 2.1/DCR](/agentkit/connectors/jammcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jentic.svg)](/agentkit/connectors/jenticmcp/) [Jentic MCP connector](/agentkit/connectors/jenticmcp/) [Connect to Jentic MCP. Search available API actions, load execution details, manage credentials, and execute API operations from your AI workflows.](/agentkit/connectors/jenticmcp/) [OAuth 2.1/DCR](/agentkit/connectors/jenticmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jiminny.svg)](/agentkit/connectors/jiminny/) [Jiminny connector](/agentkit/connectors/jiminny/) [Connect with Jiminny to access call recordings, transcripts, coaching insights, and conversation intelligence data.](/agentkit/connectors/jiminny/) [Bearer Token](/agentkit/connectors/jiminny/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/kling.svg)](/agentkit/connectors/klingmcp/) [Kling AI MCP connector](/agentkit/connectors/klingmcp/) [Kling AI is a video and image generation platform. This MCP connector exposes Kling AI capabilities — including video generation and image generation —...](/agentkit/connectors/klingmcp/) [OAuth2.1/DCR](/agentkit/connectors/klingmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/latch.svg)](/agentkit/connectors/latchbiomcp/) [Latch Bio MCP connector](/agentkit/connectors/latchbiomcp/) [Latch Bio is a cloud bioinformatics platform for running computational biology workflows. Its MCP server lets AI agents list and retrieve files, manage...](/agentkit/connectors/latchbiomcp/) [OAuth 2.1/DCR](/agentkit/connectors/latchbiomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lilt.svg)](/agentkit/connectors/liltmcp/) [LILT MCP connector](/agentkit/connectors/liltmcp/) [LILT is an enterprise translation platform that combines AI speed with human expertise to deliver accurate, domain-specific translations at scale. This...](/agentkit/connectors/liltmcp/) [OAuth 2.1/DCR](/agentkit/connectors/liltmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/listenlabs.svg)](/agentkit/connectors/listenlabsmcp/) [ListenLabs MCP connector](/agentkit/connectors/listenlabsmcp/) [Listen Labs is a qualitative research platform for creating, launching, and analyzing studies with AI assistance. This MCP connector gives AI agents...](/agentkit/connectors/listenlabsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/listenlabsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/loops.svg)](/agentkit/connectors/loopsmcp/) [Loops MCP connector](/agentkit/connectors/loopsmcp/) [Connect to Loops MCP. Create and manage loops and tasks, set priorities, track work queue stats, and ship completed loops from your AI workflows.](/agentkit/connectors/loopsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/loopsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lunarcrush.svg)](/agentkit/connectors/lunarcrushmcp/) [Lunarcrush MCP connector](/agentkit/connectors/lunarcrushmcp/) [Connect to LunarCrush MCP. Access social intelligence, sentiment analytics, and market data for crypto assets from your AI workflows.](/agentkit/connectors/lunarcrushmcp/) [OAuth 2.1/DCR](/agentkit/connectors/lunarcrushmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lusha.svg)](/agentkit/connectors/lushamcp/) [Lusha MCP connector](/agentkit/connectors/lushamcp/) [Connect to Lusha MCP. Search and enrich B2B contacts and companies, find lookalikes, run prospecting searches, and access intent and activity signals from...](/agentkit/connectors/lushamcp/) [API Key](/agentkit/connectors/lushamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/magicpatterns.svg)](/agentkit/connectors/magicpatternsmcp/) [Magic Patterns MCP connector](/agentkit/connectors/magicpatternsmcp/) [Connect to Magic Patterns, the AI-powered UI design tool. Generate, edit, and manage design components and artifacts from your AI workflows.](/agentkit/connectors/magicpatternsmcp/) [OAuth2.1/DCR](/agentkit/connectors/magicpatternsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mem.svg)](/agentkit/connectors/memmcp/) [Mem MCP connector](/agentkit/connectors/memmcp/) [A hosted MCP server that gives AI tools secure access to your Mem notes and collections — enabling AI agents to read, create, search, and organize notes...](/agentkit/connectors/memmcp/) [OAuth2.1/DCR](/agentkit/connectors/memmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mem0.svg)](/agentkit/connectors/mem0mcp/) [Mem0 MCP connector](/agentkit/connectors/mem0mcp/) [Connect to Mem0 MCP. Store, search, and retrieve persistent memory for AI agents and applications using semantic search.](/agentkit/connectors/mem0mcp/) [OAuth 2.1/DCR](/agentkit/connectors/mem0mcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/metaview.svg)](/agentkit/connectors/metaviewmcp/) [Metaview MCP connector](/agentkit/connectors/metaviewmcp/) [Metaview is an agentic recruiting platform that automates end-to-end hiring workflows — from candidate sourcing and outreach to interview note-taking and...](/agentkit/connectors/metaviewmcp/) [OAuth 2.1/DCR](/agentkit/connectors/metaviewmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mintlify.svg)](/agentkit/connectors/mintlifymcp/) [Mintlify MCP connector](/agentkit/connectors/mintlifymcp/) [Connect to Mintlify MCP. Read and edit documentation pages, manage navigation nodes, search content, and publish changes via pull requests from your AI...](/agentkit/connectors/mintlifymcp/) [OAuth 2.1/DCR](/agentkit/connectors/mintlifymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/motherduck.svg)](/agentkit/connectors/motherduckmcp/) [MotherDuck MCP connector](/agentkit/connectors/motherduckmcp/) [Connect to MotherDuck MCP. Query and analyze DuckDB databases, explore schemas, create visualizations, and automate data workflows from your AI workflows.](/agentkit/connectors/motherduckmcp/) [OAuth 2.1/DCR](/agentkit/connectors/motherduckmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/neon.svg)](/agentkit/connectors/neonmcp/) [Neon MCP connector](/agentkit/connectors/neonmcp/) [Connect to Neon MCP. Manage Neon serverless Postgres databases, projects, branches, and queries from your AI workflows.](/agentkit/connectors/neonmcp/) [OAuth 2.1/DCR](/agentkit/connectors/neonmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/nimble.svg)](/agentkit/connectors/nimblemcp/) [Nimble MCP connector](/agentkit/connectors/nimblemcp/) [Connect to Nimble MCP. Search the web across multiple engines, extract content from any URL, crawl websites at scale, discover all URLs on a site, and run...](/agentkit/connectors/nimblemcp/) [Bearer Token](/agentkit/connectors/nimblemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/openrouter.svg)](/agentkit/connectors/openroutermcp/) [OpenRouter MCP connector](/agentkit/connectors/openroutermcp/) [Connect to OpenRouter's MCP server to access unified LLM routing, model discovery, and generation tools directly from your AI workflows.](/agentkit/connectors/openroutermcp/) [OAuth 2.1/DCR](/agentkit/connectors/openroutermcp/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/parallel-ai.svg)](/agentkit/connectors/parallelaitaskmcp/) [Parallel AI Task MCP connector](/agentkit/connectors/parallelaitaskmcp/) [Connect to Parallel AI Task MCP to run deep research tasks and task groups directly from your AI workflows.](/agentkit/connectors/parallelaitaskmcp/) [Bearer Token](/agentkit/connectors/parallelaitaskmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/phantombuster.svg)](/agentkit/connectors/phantombuster/) [PhantomBuster connector](/agentkit/connectors/phantombuster/) [Connect to PhantomBuster to automate web scraping and data extraction workflows. Launch, monitor, and manage automation agents that extract data from...](/agentkit/connectors/phantombuster/) [API Key](/agentkit/connectors/phantombuster/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/phantombuster.svg)](/agentkit/connectors/phantombustermcp/) [PhantomBuster MCP connector](/agentkit/connectors/phantombustermcp/) [Connect to PhantomBuster MCP server to launch and manage web automation agents, retrieve scraping outputs, manage leads, and explore workspace resources...](/agentkit/connectors/phantombustermcp/) [OAuth 2.1/DCR](/agentkit/connectors/phantombustermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/planetscale.svg)](/agentkit/connectors/planetscalemcp/) [Planet Scale MCP connector](/agentkit/connectors/planetscalemcp/) [Connect to PlanetScale MCP. Run SQL queries, inspect database branches and schemas, get query performance insights, and manage organizations and invoices...](/agentkit/connectors/planetscalemcp/) [OAuth 2.1/DCR](/agentkit/connectors/planetscalemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/postman.svg)](/agentkit/connectors/postmanmcp/) [Postman MCP connector](/agentkit/connectors/postmanmcp/) [Connect to the Postman MCP server to manage collections, workspaces, environments, and APIs directly from your AI workflows.](/agentkit/connectors/postmanmcp/) [OAuth 2.1/DCR](/agentkit/connectors/postmanmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/privacy.svg)](/agentkit/connectors/privacymcp/) [Privacy MCP connector](/agentkit/connectors/privacymcp/) [Connect to Privacy MCP. Create and manage virtual cards, set spend limits, pause or close cards, and review transactions from your AI workflows.](/agentkit/connectors/privacymcp/) [OAuth 2.1/DCR](/agentkit/connectors/privacymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/profound.svg)](/agentkit/connectors/profoundmcp/) [Profound MCP connector](/agentkit/connectors/profoundmcp/) [Profound is an AI search visibility and marketing analytics platform that helps brands understand and optimize their presence across AI-powered answer...](/agentkit/connectors/profoundmcp/) [OAuth 2.1/DCR](/agentkit/connectors/profoundmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/quicknode.svg)](/agentkit/connectors/quicknodemcp/) [Quicknode MCP connector](/agentkit/connectors/quicknodemcp/) [Connect to QuickNode MCP. Create and manage blockchain RPC endpoints, configure security rules, set rate limits, and monitor usage and logs from your AI...](/agentkit/connectors/quicknodemcp/) [OAuth 2.1/DCR](/agentkit/connectors/quicknodemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/quizvideo.svg)](/agentkit/connectors/quizvideomcp/) [Quiz.Video MCP connector](/agentkit/connectors/quizvideomcp/) [Quiz.Video is an AI-powered platform for creating short-form quiz and flashcard videos. Transform topics, URLs, or documents into shareable quiz and...](/agentkit/connectors/quizvideomcp/) [OAuth 2.1/DCR](/agentkit/connectors/quizvideomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/readai.svg)](/agentkit/connectors/readaimcp/) [Read AI MCP connector](/agentkit/connectors/readaimcp/) [Connect to Read AI to access your meeting intelligence — transcripts, summaries, action items, and insights from meetings, emails, and chats. Retrieve...](/agentkit/connectors/readaimcp/) [OAuth2.1/DCR](/agentkit/connectors/readaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/recraft.svg)](/agentkit/connectors/recraftmcp/) [Recraft AI MCP connector](/agentkit/connectors/recraftmcp/) [Connect to Recraft AI MCP. Generate AI-powered images, vectors, icons, and mockups from your AI agents using Recraft's creative design tools.](/agentkit/connectors/recraftmcp/) [OAuth 2.1/DCR](/agentkit/connectors/recraftmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/replit.svg)](/agentkit/connectors/replitmcp/) [Replit MCP connector](/agentkit/connectors/replitmcp/) [Connect to Replit MCP. Create, update, and inspect Replit apps from natural-language prompts, list your apps, and resolve apps by name from your AI...](/agentkit/connectors/replitmcp/) [OAuth 2.1/DCR](/agentkit/connectors/replitmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/revealedai.svg)](/agentkit/connectors/revealedaimcp/) [Revealed AI MCP connector](/agentkit/connectors/revealedaimcp/) [Connect to Revealed AI. Track account signals, buyer personas, and people changes to surface timely outreach actions and account intelligence for B2B...](/agentkit/connectors/revealedaimcp/) [OAuth 2.1/DCR](/agentkit/connectors/revealedaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/runware.svg)](/agentkit/connectors/runwaremcp/) [Runware MCP connector](/agentkit/connectors/runwaremcp/) [Connect to Runware's MCP server to generate and edit images, video, audio, and 3D assets using thousands of AI models through a single API.](/agentkit/connectors/runwaremcp/) [OAuth2.1/DCR](/agentkit/connectors/runwaremcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/scrapfly.svg)](/agentkit/connectors/scarpflymcp/) [Scarpfly MCP connector](/agentkit/connectors/scarpflymcp/) [Connect to Scrapfly MCP. Scrape web pages, take screenshots, and control a cloud browser with anti-bot bypass, JS rendering, and proxy support.](/agentkit/connectors/scarpflymcp/) [OAuth 2.1/DCR](/agentkit/connectors/scarpflymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/scholargateway.svg)](/agentkit/connectors/scholargateway/) [Scholar Gateway MCP connector](/agentkit/connectors/scholargateway/) [Connect to Scholar Gateway to search Wiley's peer-reviewed academic literature — 8M+ articles from 2,000+ journals spanning sciences, healthcare...](/agentkit/connectors/scholargateway/) [OAuth2.1/DCR](/agentkit/connectors/scholargateway/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/splice.svg)](/agentkit/connectors/splicemcp/) [Splice MCP connector](/agentkit/connectors/splicemcp/) [Connect to Splice MCP. Search the Splice sample catalog, create and update multi-track stacks, download audio assets, and generate arrangements from text...](/agentkit/connectors/splicemcp/) [OAuth 2.1/DCR](/agentkit/connectors/splicemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sportradar.svg)](/agentkit/connectors/sportradarmcp/) [Sportradar MCP connector](/agentkit/connectors/sportradarmcp/) [Connect to Sportradar MCP. Browse and search sports data API specs, discover endpoints, check coverage, and access guide pages from your AI workflows.](/agentkit/connectors/sportradarmcp/) [OAuth 2.1/DCR](/agentkit/connectors/sportradarmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/stackai.svg)](/agentkit/connectors/stackaimcp/) [Stack.ai MCP connector](/agentkit/connectors/stackaimcp/) [Connect to Stack AI MCP. Build, run, and manage AI workflow projects, search knowledge bases, list integration providers, and inspect execution traces...](/agentkit/connectors/stackaimcp/) [OAuth 2.1/DCR](/agentkit/connectors/stackaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/supadata.svg)](/agentkit/connectors/supadatamcp/) [Supadata MCP connector](/agentkit/connectors/supadatamcp/) [Connect with Supadata MCP to extract transcripts, metadata, and structured content from YouTube, social media, and the web using AI.](/agentkit/connectors/supadatamcp/) [OAuth 2.1/DCR](/agentkit/connectors/supadatamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sybill.svg)](/agentkit/connectors/sybilmcp/) [Sybill MCP connector](/agentkit/connectors/sybilmcp/) [Connect to Sybill. Access AI-generated summaries of sales calls, deals, accounts, and conversations to accelerate B2B revenue workflows.](/agentkit/connectors/sybilmcp/) [OAuth 2.1/DCR](/agentkit/connectors/sybilmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/synthesize-bio.svg)](/agentkit/connectors/synthesizebiomcp/) [Synthesize Bio MCP connector](/agentkit/connectors/synthesizebiomcp/) [Connect to Synthesize Bio MCP. Run differential gene expression analysis, resolve sample metadata, and retrieve results and raw counts data from your AI...](/agentkit/connectors/synthesizebiomcp/) [OAuth 2.1/DCR](/agentkit/connectors/synthesizebiomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tactiq.svg)](/agentkit/connectors/tactiqmcp/) [Tactiq MCP connector](/agentkit/connectors/tactiqmcp/) [Tactiq captures and transcribes meetings in real time, turning conversations into AI-generated notes, summaries, and action items.](/agentkit/connectors/tactiqmcp/) [OAuth2.1/DCR](/agentkit/connectors/tactiqmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tavily.svg)](/agentkit/connectors/tavilymcp/) [Tavily MCP connector](/agentkit/connectors/tavilymcp/) [Connect to Tavily MCP. Search the web, crawl websites, extract content, map site structure, and run deep research using Tavily's AI-powered search API.](/agentkit/connectors/tavilymcp/) [OAuth 2.1/DCR](/agentkit/connectors/tavilymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/telnyx.svg)](/agentkit/connectors/telnyxmcp/) [Telnyx MCP connector](/agentkit/connectors/telnyxmcp/) [Telnyx is a communications platform for voice, messaging, and AI. This MCP connector lets AI agents manage phone numbers, send SMS and MMS, place and...](/agentkit/connectors/telnyxmcp/) [OAuth 2.1/DCR](/agentkit/connectors/telnyxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tinyfish.svg)](/agentkit/connectors/tinyfishmcp/) [Tinyfish MCP connector](/agentkit/connectors/tinyfishmcp/) [Connect to Tinyfish MCP. Run browser-based web automations, fetch page content, and search the web using a real cloud Chrome browser.](/agentkit/connectors/tinyfishmcp/) [OAuth 2.1/DCR](/agentkit/connectors/tinyfishmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/v0.svg)](/agentkit/connectors/v0mcp/) [v0 MCP connector](/agentkit/connectors/v0mcp/) [Connect to v0 by Vercel to generate and iterate on web app UIs from natural language. Create chats, send follow-up messages, and inspect v0 Platform chats...](/agentkit/connectors/v0mcp/) [Bearer Token](/agentkit/connectors/v0mcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/vapi.svg)](/agentkit/connectors/vapimcp/) [Vapi MCP connector](/agentkit/connectors/vapimcp/) [Vapi is an AI-powered voice platform for building, testing, and deploying voice AI agents. This MCP connector enables AI agents to manage Vapi assistants...](/agentkit/connectors/vapimcp/) [Bearer Token](/agentkit/connectors/vapimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/vibeprospecting.svg)](/agentkit/connectors/vibeprospectingmcp/) [Vibe Prospecting MCP connector](/agentkit/connectors/vibeprospectingmcp/) [Connect to Vibe Prospecting by Explorium to build B2B lead lists, research companies and prospects, enrich contacts, and personalize outreach from your AI...](/agentkit/connectors/vibeprospectingmcp/) [OAuth 2.1/DCR](/agentkit/connectors/vibeprospectingmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/whimsical.svg)](/agentkit/connectors/whimsicalmcp/) [Whimsical MCP connector](/agentkit/connectors/whimsicalmcp/) [Connect to Whimsical MCP. Create and edit flowcharts, mind maps, wireframes, and docs, and manage boards, comments, and workspaces from your AI workflows.](/agentkit/connectors/whimsicalmcp/) [OAuth 2.1/DCR](/agentkit/connectors/whimsicalmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/wix.svg)](/agentkit/connectors/wixmcp/) [Wix MCP connector](/agentkit/connectors/wixmcp/) [Connect to Wix MCP. Build and manage Wix sites, call REST APIs, search documentation, upload media, and suggest domains from your AI workflows.](/agentkit/connectors/wixmcp/) [OAuth 2.1/DCR](/agentkit/connectors/wixmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/you.svg)](/agentkit/connectors/youmcp/) [You.com MCP connector](/agentkit/connectors/youmcp/) [Connect to You.com MCP. Search the web, research topics with cited sources, and extract full page content using You.com's AI-powered search and research...](/agentkit/connectors/youmcp/) [Bearer Token](/agentkit/connectors/youmcp/) ## Analytics [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/adobe.svg)](/agentkit/connectors/adobemarketingagentmcp/) [Adobe Marketing Agent MCP connector](/agentkit/connectors/adobemarketingagentmcp/) [Connect to Adobe Marketing Cloud. Manage campaigns, analytics, and journeys using a natural-language AI assistant.](/agentkit/connectors/adobemarketingagentmcp/) [OAuth 2.1/DCR](/agentkit/connectors/adobemarketingagentmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/adzviser.svg)](/agentkit/connectors/adzvisermcp/) [Adzviser MCP connector](/agentkit/connectors/adzvisermcp/) [Connect to Adzviser MCP to query real-time marketing analytics across 46+ platforms - Google Ads, Facebook Ads, GA4, TikTok, LinkedIn, and more - from a...](/agentkit/connectors/adzvisermcp/) [OAuth 2.1/DCR](/agentkit/connectors/adzvisermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/agencyanalytics.svg)](/agentkit/connectors/agencyanalyticsmcp/) [Agency Analytics MCP connector](/agentkit/connectors/agencyanalyticsmcp/) [Agency Analytics is a marketing reporting platform that enables digital agencies to monitor SEO, PPC, social media, and other channel performance in...](/agentkit/connectors/agencyanalyticsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/agencyanalyticsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airbyte.svg)](/agentkit/connectors/airbytemcp/) [Airbyte MCP connector](/agentkit/connectors/airbytemcp/) [Connect to Airbyte's MCP server to manage data pipelines, sources, destinations, and connections for your data integration workflows.](/agentkit/connectors/airbytemcp/) [OAuth2.1/DCR](/agentkit/connectors/airbytemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airops.svg)](/agentkit/connectors/airopsmcp/) [Airops MCP connector](/agentkit/connectors/airopsmcp/) [Connect to AirOps MCP. Manage brand kits, run AI-powered analytics, track AEO citations, and automate content workflows from your AI agents.](/agentkit/connectors/airopsmcp/) [API Key](/agentkit/connectors/airopsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airtable.svg)](/agentkit/connectors/airtable/) [Airtable connector](/agentkit/connectors/airtable/) [Connect to Airtable. Manage databases, tables, records, and collaborate on structured data](/agentkit/connectors/airtable/) [OAuth 2.0](/agentkit/connectors/airtable/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/amplitude.svg)](/agentkit/connectors/amplitudeanalytics/) [Amplitude Analytics connector](/agentkit/connectors/amplitudeanalytics/) [Connect to Amplitude's analytics REST APIs: event segmentation, funnels, cohorts, taxonomy, chart annotations, session replay, export, releases, streaming...](/agentkit/connectors/amplitudeanalytics/) [API Key + Secret Key](/agentkit/connectors/amplitudeanalytics/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/amplitude.svg)](/agentkit/connectors/amplitudeexperimentmanagement/) [Amplitude Experiment Management connector](/agentkit/connectors/amplitudeexperimentmanagement/) [Manage Amplitude Experiment feature flags, experiments, mutex groups, holdouts, and deployments. Separate connector from Experiment Evaluation (real-time...](/agentkit/connectors/amplitudeexperimentmanagement/) [Bearer Token](/agentkit/connectors/amplitudeexperimentmanagement/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/redshift.svg)](/agentkit/connectors/redshift/) [AWS Redshift connector](/agentkit/connectors/redshift/) [Connect Amazon Redshift to Scalekit with the Trusted IDP flow so agents run SQL over federated AWS credentials, with no long-lived keys stored.](/agentkit/connectors/redshift/) [Trusted IDP](/agentkit/connectors/redshift/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/axiom.svg)](/agentkit/connectors/axiommcp/) [Axiom MCP connector](/agentkit/connectors/axiommcp/) [Axiom is a cloud-native data analytics and observability platform for ingesting, storing, and querying logs, events, traces, and metrics at scale. The MCP...](/agentkit/connectors/axiommcp/) [OAuth2.1/DCR](/agentkit/connectors/axiommcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bigquery.svg)](/agentkit/connectors/bigqueryserviceaccount/) [BigQuery (Service Account) connector](/agentkit/connectors/bigqueryserviceaccount/) [Connect to Google BigQuery using a GCP service account for server-to-server authentication without user login.](/agentkit/connectors/bigqueryserviceaccount/) [Service Account](/agentkit/connectors/bigqueryserviceaccount/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/biomni.svg)](/agentkit/connectors/biomnimcp/) [Biomni MCP connector](/agentkit/connectors/biomnimcp/) [Connect to Biomni MCP by phylo.bio, an AI biomedical research assistant. Analyze life-sciences data, interpret genomic variants, query curated databases...](/agentkit/connectors/biomnimcp/) [OAuth2.1/DCR](/agentkit/connectors/biomnimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bitquery.svg)](/agentkit/connectors/bitquerymcp/) [Bitquery MCP connector](/agentkit/connectors/bitquerymcp/) [Connect to Bitquery MCP. Query on-chain DEX trading data, token prices, OHLCV series, trader profiles, and trending tokens across multiple blockchains...](/agentkit/connectors/bitquerymcp/) [OAuth 2.1/DCR](/agentkit/connectors/bitquerymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/brave.svg)](/agentkit/connectors/brave/) [Brave Search connector](/agentkit/connectors/brave/) [Connect to Brave Search to perform web, image, video, and news searches with privacy-focused results, plus AI-powered suggestions and spellcheck.](/agentkit/connectors/brave/) [API Key](/agentkit/connectors/brave/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/carta.svg)](/agentkit/connectors/cartamcp/) [Carta MCP connector](/agentkit/connectors/cartamcp/) [Connect to Carta. Manage equity cap tables, fund administration, company accounts, and ownership data for venture-backed companies.](/agentkit/connectors/cartamcp/) [OAuth 2.1/DCR](/agentkit/connectors/cartamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/catchr.svg)](/agentkit/connectors/catchrmcp/) [Catchr MCP connector](/agentkit/connectors/catchrmcp/) [Catchr is a data connector platform that syncs marketing and analytics data from ad platforms (Google Ads, Facebook Ads, etc.) to data warehouses and BI...](/agentkit/connectors/catchrmcp/) [OAuth2.1/DCR](/agentkit/connectors/catchrmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clarify.svg)](/agentkit/connectors/clarifymcp/) [Clarify MCP connector](/agentkit/connectors/clarifymcp/) [Connect to Clarify MCP to manage CRM records, leads, campaigns, lists, and analytics directly from your AI workflows.](/agentkit/connectors/clarifymcp/) [OAuth 2.1/DCR](/agentkit/connectors/clarifymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clickhouse.svg)](/agentkit/connectors/clickhouse/) [Clickhouse MCP connector](/agentkit/connectors/clickhouse/) [Connect to ClickHouse MCP to query, analyze, and manage your ClickHouse databases directly from your AI workflows.](/agentkit/connectors/clickhouse/) [OAuth 2.1/DCR](/agentkit/connectors/clickhouse/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/coinmarketcap.svg)](/agentkit/connectors/coinmarketcapmcp/) [CoinMarketCap MCP connector](/agentkit/connectors/coinmarketcapmcp/) [Connect to CoinMarketCap MCP. Access real-time crypto quotes, market metrics, technical analysis, trending narratives, and news from your AI workflows.](/agentkit/connectors/coinmarketcapmcp/) [OAuth 2.1/DCR](/agentkit/connectors/coinmarketcapmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/commonroom.svg)](/agentkit/connectors/commonroommcp/) [Commonroom MCP connector](/agentkit/connectors/commonroommcp/) [Connect to Common Room MCP to manage community members, objects, and feedback data directly from your AI workflows.](/agentkit/connectors/commonroommcp/) [OAuth 2.1/DCR](/agentkit/connectors/commonroommcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/customerio.svg)](/agentkit/connectors/customeriomcp/) [Customer.io MCP connector](/agentkit/connectors/customeriomcp/) [Connect to Customer.io MCP to manage customers, campaigns, and events](/agentkit/connectors/customeriomcp/) [OAuth 2.1/DCR](/agentkit/connectors/customeriomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/databox.svg)](/agentkit/connectors/databoxmcp/) [Databox MCP connector](/agentkit/connectors/databoxmcp/) [Connect to Databox MCP. Query metrics, manage dashboards, and push custom data to your Databox analytics and reporting platform.](/agentkit/connectors/databoxmcp/) [OAuth 2.1/DCR](/agentkit/connectors/databoxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/databricks-1.svg)](/agentkit/connectors/databricksworkspace/) [Databricks Workspace connector](/agentkit/connectors/databricksworkspace/) [Connect to Databricks Workspace APIs using a Service Principal with OAuth 2.0 client credentials to manage clusters, jobs, notebooks, SQL, and more.](/agentkit/connectors/databricksworkspace/) [Service Principal (OAuth 2.0)](/agentkit/connectors/databricksworkspace/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dataforseo.svg)](/agentkit/connectors/dataforseomcp/) [Dataforseo MCP connector](/agentkit/connectors/dataforseomcp/) [Connect to DataForSEO. Access real-time SEO data including SERP results, keyword analytics, backlinks analysis, domain technologies, and AI visibility...](/agentkit/connectors/dataforseomcp/) [OAuth 2.1/DCR](/agentkit/connectors/dataforseomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/diarize.svg)](/agentkit/connectors/diarize/) [Diarize connector](/agentkit/connectors/diarize/) [Connect to Diarize to transcribe and diarize audio and video content from YouTube, X, Instagram, and TikTok. Submit transcription jobs and retrieve...](/agentkit/connectors/diarize/) [Bearer Token](/agentkit/connectors/diarize/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dovetail.svg)](/agentkit/connectors/dovetailmcp/) [Dovetail MCP connector](/agentkit/connectors/dovetailmcp/) [Connect to Dovetail, the AI-native UX research platform. Access projects, insights, and data from your AI workflows.](/agentkit/connectors/dovetailmcp/) [Bearer Token](/agentkit/connectors/dovetailmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/eodhd.svg)](/agentkit/connectors/eodhdmcp/) [EODHD MCP connector](/agentkit/connectors/eodhdmcp/) [EODHD (End of Day Historical Data) provides comprehensive financial market data including end-of-day stock prices, historical OHLCV data, fundamentals...](/agentkit/connectors/eodhdmcp/) [OAuth 2.1/DCR](/agentkit/connectors/eodhdmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/exa.svg)](/agentkit/connectors/exa/) [Exa connector](/agentkit/connectors/exa/) [Connect to Exa to perform AI-powered semantic web search, crawl websites for structured content, get natural language answers from the web, run in-depth...](/agentkit/connectors/exa/) [API Key](/agentkit/connectors/exa/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/financialdatasets.svg)](/agentkit/connectors/financialdatasetsmcp/) [Financial Datasets MCP connector](/agentkit/connectors/financialdatasetsmcp/) [Financial Datasets provides an MCP interface to financial data APIs covering stock prices, financial statements, earnings, insider trades, and...](/agentkit/connectors/financialdatasetsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/financialdatasetsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fiscalai.svg)](/agentkit/connectors/fiscalaimcp/) [FiscalAI MCP connector](/agentkit/connectors/fiscalaimcp/) [Connect to FiscalAI MCP. Access financial data for public companies including SEC filings, earnings, stock prices, financial ratios, and company profiles.](/agentkit/connectors/fiscalaimcp/) [OAuth 2.1/DCR](/agentkit/connectors/fiscalaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gainsight.svg)](/agentkit/connectors/gainsight/) [Gainsight connector](/agentkit/connectors/gainsight/) [Connect to Gainsight Customer Success to manage companies, contacts, calls to action, success plans, timeline activities, and custom objects. Power...](/agentkit/connectors/gainsight/) [API Key](/agentkit/connectors/gainsight/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bigquery.svg)](/agentkit/connectors/bigquery/) [Google BigQuery connector](/agentkit/connectors/bigquery/) [BigQuery is Google Cloud’s fully-managed enterprise data warehouse for analytics at scale.](/agentkit/connectors/bigquery/) [OAuth 2.0](/agentkit/connectors/bigquery/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google.svg)](/agentkit/connectors/googlebusinessprofile/) [Google Business Profile connector](/agentkit/connectors/googlebusinessprofile/) [Google Business Profile lets businesses manage their presence across Google Search and Maps — business information, locations, performance/insights...](/agentkit/connectors/googlebusinessprofile/) [OAuth 2.0](/agentkit/connectors/googlebusinessprofile/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/googlelooker.svg)](/agentkit/connectors/googlelooker/) [Google Looker connector](/agentkit/connectors/googlelooker/) [Connect to Google Looker or self-hosted Looker Core. Browse dashboards, run Looks, query LookML models, and access BI data programmatically.](/agentkit/connectors/googlelooker/) [OAuth 2.0](/agentkit/connectors/googlelooker/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_sheets.svg)](/agentkit/connectors/googlesheets/) [Google Sheets connector](/agentkit/connectors/googlesheets/) [Connect to Google Sheets. Create, edit, and analyze spreadsheets with powerful data management capabilities](/agentkit/connectors/googlesheets/) [OAuth 2.0](/agentkit/connectors/googlesheets/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gtmetrix.svg)](/agentkit/connectors/gtmetrixmcp/) [GTmetrix MCP connector](/agentkit/connectors/gtmetrixmcp/) [Connect to GTmetrix MCP to analyze web page performance, run speed tests, monitor Core Web Vitals, and get actionable optimization recommendations...](/agentkit/connectors/gtmetrixmcp/) [OAuth 2.1/DCR](/agentkit/connectors/gtmetrixmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/harvestapi.svg)](/agentkit/connectors/harvestapi/) [HarvestAPI connector](/agentkit/connectors/harvestapi/) [Connect to HarvestAPI to scrape LinkedIn profiles, companies, and job listings, and search for people and jobs using LinkedIn data. Enables AI agents to...](/agentkit/connectors/harvestapi/) [API Key](/agentkit/connectors/harvestapi/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/hex.svg)](/agentkit/connectors/hexmcp/) [Hex MCP connector](/agentkit/connectors/hexmcp/) [Connect to Hex MCP. Create and continue data analysis threads, search projects, and query your data using natural language from your AI workflows.](/agentkit/connectors/hexmcp/) [OAuth 2.1/DCR](/agentkit/connectors/hexmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/hub_spot.svg)](/agentkit/connectors/hubspotmcp/) [HubSpot MCP connector](/agentkit/connectors/hubspotmcp/) [Connect to HubSpot MCP. Manage CRM contacts, companies, deals, landing pages, campaigns, and analytics from your AI workflows.](/agentkit/connectors/hubspotmcp/) [OAuth 2.1](/agentkit/connectors/hubspotmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/leadboxer.svg)](/agentkit/connectors/leadboxermcp/) [LeadBoxer MCP connector](/agentkit/connectors/leadboxermcp/) [Connect to LeadBoxer MCP to identify anonymous website visitors and enrich them with firmographic data. LeadBoxer is a B2B lead generation and website...](/agentkit/connectors/leadboxermcp/) [OAuth 2.1/DCR](/agentkit/connectors/leadboxermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/leadfeeder.svg)](/agentkit/connectors/leadfeedermcp/) [Leadfeeder MCP connector](/agentkit/connectors/leadfeedermcp/) [Connect to Leadfeeder's MCP server to identify website visitors, track B2B leads, and surface company-level intent data directly from your AI workflows.](/agentkit/connectors/leadfeedermcp/) [OAuth2.1/DCR](/agentkit/connectors/leadfeedermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/leadiq.svg)](/agentkit/connectors/leadiq/) [LeadIQ connector](/agentkit/connectors/leadiq/) [Connect to LeadIQ to search and enrich B2B contacts and companies with verified emails, direct dials, and mobile numbers. Build prospect lists and power...](/agentkit/connectors/leadiq/) [API Key](/agentkit/connectors/leadiq/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/leadiq.svg)](/agentkit/connectors/leadiqmcp/) [LeadIQ MCP connector](/agentkit/connectors/leadiqmcp/) [Connect to LeadIQ via MCP to search and enrich B2B contacts and companies. Access real-time prospect data, company intelligence, and email/phone...](/agentkit/connectors/leadiqmcp/) [OAuth2.1/DCR](/agentkit/connectors/leadiqmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/linkly.png)](/agentkit/connectors/linklymcp/) [LinklyHQ MCP connector](/agentkit/connectors/linklymcp/) [LinklyHQ is a URL shortening and link management platform offering click analytics, custom domains, UTM tracking, QR codes, and webhook integrations for...](/agentkit/connectors/linklymcp/) [OAuth 2.1/PKCE](/agentkit/connectors/linklymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/listenlabs.svg)](/agentkit/connectors/listenlabsmcp/) [ListenLabs MCP connector](/agentkit/connectors/listenlabsmcp/) [Listen Labs is a qualitative research platform for creating, launching, and analyzing studies with AI assistance. This MCP connector gives AI agents...](/agentkit/connectors/listenlabsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/listenlabsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/logrocket.svg)](/agentkit/connectors/logrocketmcp/) [LogRocket MCP connector](/agentkit/connectors/logrocketmcp/) [Connect to LogRocket to access session data, query analytics, investigate user-reported issues, and detect regressions directly from your AI workflows.](/agentkit/connectors/logrocketmcp/) [OAuth2.1/DCR](/agentkit/connectors/logrocketmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lunarcrush.svg)](/agentkit/connectors/lunarcrushmcp/) [Lunarcrush MCP connector](/agentkit/connectors/lunarcrushmcp/) [Connect to LunarCrush MCP. Access social intelligence, sentiment analytics, and market data for crypto assets from your AI workflows.](/agentkit/connectors/lunarcrushmcp/) [OAuth 2.1/DCR](/agentkit/connectors/lunarcrushmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mailchimp.svg)](/agentkit/connectors/mailchimp/) [Mailchimp connector](/agentkit/connectors/mailchimp/) [Connect to Mailchimp to manage audiences, campaigns, templates, automations, and reports.](/agentkit/connectors/mailchimp/) [OAuth 2.0](/agentkit/connectors/mailchimp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mercury.svg)](/agentkit/connectors/mercurymcp/) [Mercury MCP connector](/agentkit/connectors/mercurymcp/) [Connect to Mercury. Access accounts, transactions, recipients, invoices, treasury, webhooks, and approval requests for startup banking workflows.](/agentkit/connectors/mercurymcp/) [OAuth 2.1/DCR](/agentkit/connectors/mercurymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/metricool.svg)](/agentkit/connectors/metricoolmcp/) [Metricool MCP connector](/agentkit/connectors/metricoolmcp/) [Metricool is a social media analytics and scheduling platform for managing, analyzing, and scheduling content across Instagram, Twitter/X, Facebook...](/agentkit/connectors/metricoolmcp/) [OAuth2.1/DCR](/agentkit/connectors/metricoolmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/microsoft365.svg)](/agentkit/connectors/microsoft365/) [Microsoft 365 connector](/agentkit/connectors/microsoft365/) [Connect to Microsoft 365. Unified access to Outlook, Excel, Word, OneNote, OneDrive, SharePoint, and Teams through Microsoft Graph API.](/agentkit/connectors/microsoft365/) [OAuth 2.0](/agentkit/connectors/microsoft365/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/excel.svg)](/agentkit/connectors/microsoftexcel/) [Microsoft Excel connector](/agentkit/connectors/microsoftexcel/) [Connect to Microsoft Excel. Access, read, and modify spreadsheets stored in OneDrive or SharePoint through Microsoft Graph API.](/agentkit/connectors/microsoftexcel/) [OAuth 2.0](/agentkit/connectors/microsoftexcel/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mixpanel.svg)](/agentkit/connectors/mixpanelanalytics/) [Mixpanel Analytics connector](/agentkit/connectors/mixpanelanalytics/) [Connect to Mixpanel's Query API, Lexicon Schemas, and Warehouse Connectors to run segmentation, funnel, retention, and Insights reports, execute custom...](/agentkit/connectors/mixpanelanalytics/) [Service Account](/agentkit/connectors/mixpanelanalytics/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mixpanel.svg)](/agentkit/connectors/mixpanelcompliance/) [Mixpanel Compliance connector](/agentkit/connectors/mixpanelcompliance/) [Connect to Mixpanel's GDPR/CCPA compliance API to submit and track end-user data deletion (right to erasure) and data retrieval (subject access) requests....](/agentkit/connectors/mixpanelcompliance/) [Bearer Token](/agentkit/connectors/mixpanelcompliance/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mixpanel.svg)](/agentkit/connectors/mixpanelingestion/) [Mixpanel Ingestion connector](/agentkit/connectors/mixpanelingestion/) [Connect to Mixpanel's Ingestion API to track events, manage user and group profiles, resolve identities, replace lookup tables, and evaluate feature...](/agentkit/connectors/mixpanelingestion/) [Service Account](/agentkit/connectors/mixpanelingestion/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/motherduck.svg)](/agentkit/connectors/motherduckmcp/) [MotherDuck MCP connector](/agentkit/connectors/motherduckmcp/) [Connect to MotherDuck MCP. Query and analyze DuckDB databases, explore schemas, create visualizations, and automate data workflows from your AI workflows.](/agentkit/connectors/motherduckmcp/) [OAuth 2.1/DCR](/agentkit/connectors/motherduckmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pendo.svg)](/agentkit/connectors/pendomcp/) [Pendo MCP connector](/agentkit/connectors/pendomcp/) [Connect to Pendo MCP to access product analytics, user guidance, and engagement data directly from your AI workflows.](/agentkit/connectors/pendomcp/) [OAuth 2.1/DCR](/agentkit/connectors/pendomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/posthog-1.svg)](/agentkit/connectors/posthogmcp/) [Posthog MCP connector](/agentkit/connectors/posthogmcp/) [Connect to Posthog MCP to enable your AI agents and tools to directly interact with PostHog's products.](/agentkit/connectors/posthogmcp/) [OAuth 2.1/DCR](/agentkit/connectors/posthogmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/profound.svg)](/agentkit/connectors/profoundmcp/) [Profound MCP connector](/agentkit/connectors/profoundmcp/) [Profound is an AI search visibility and marketing analytics platform that helps brands understand and optimize their presence across AI-powered answer...](/agentkit/connectors/profoundmcp/) [OAuth 2.1/DCR](/agentkit/connectors/profoundmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/revealedai.svg)](/agentkit/connectors/revealedaimcp/) [Revealed AI MCP connector](/agentkit/connectors/revealedaimcp/) [Connect to Revealed AI. Track account signals, buyer personas, and people changes to surface timely outreach actions and account intelligence for B2B...](/agentkit/connectors/revealedaimcp/) [OAuth 2.1/DCR](/agentkit/connectors/revealedaimcp/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/rize.svg)](/agentkit/connectors/rizemcp/) [Rize MCP connector](/agentkit/connectors/rizemcp/) [Connect to Rize MCP using OAuth 2.1 with MCP discovery and dynamic client registration. Access and analyze your time tracking data, projects, clients...](/agentkit/connectors/rizemcp/) [OAuth 2.1/DCR](/agentkit/connectors/rizemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/snowflake.svg)](/agentkit/connectors/snowflake/) [Snowflake connector](/agentkit/connectors/snowflake/) [Connect to Snowflake to manage and analyze your data warehouse workloads](/agentkit/connectors/snowflake/) [OAuth 2.0](/agentkit/connectors/snowflake/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/snowflake.svg)](/agentkit/connectors/snowflakekeyauth/) [Snowflake Key Pair Auth connector](/agentkit/connectors/snowflakekeyauth/) [Connect to Snowflake via Public Private Key Pair to manage and analyze your data warehouse workloads](/agentkit/connectors/snowflakekeyauth/) [Bearer Token](/agentkit/connectors/snowflakekeyauth/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sportradar.svg)](/agentkit/connectors/sportradarmcp/) [Sportradar MCP connector](/agentkit/connectors/sportradarmcp/) [Connect to Sportradar MCP. Browse and search sports data API specs, discover endpoints, check coverage, and access guide pages from your AI workflows.](/agentkit/connectors/sportradarmcp/) [OAuth 2.1/DCR](/agentkit/connectors/sportradarmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/storeleads.svg)](/agentkit/connectors/storeleadsmcp/) [StoreLeads MCP connector](/agentkit/connectors/storeleadsmcp/) [Connect to StoreLeads MCP to discover, search, and analyze e-commerce stores and their technology stack from your AI workflows.](/agentkit/connectors/storeleadsmcp/) [Bearer Token](/agentkit/connectors/storeleadsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/supadata.svg)](/agentkit/connectors/supadata/) [Supadata connector](/agentkit/connectors/supadata/) [Connect with Supadata to extract transcripts, metadata, and structured content from YouTube, social media, and the web using AI.](/agentkit/connectors/supadata/) [API Key](/agentkit/connectors/supadata/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/supadata.svg)](/agentkit/connectors/supadatamcp/) [Supadata MCP connector](/agentkit/connectors/supadatamcp/) [Connect with Supadata MCP to extract transcripts, metadata, and structured content from YouTube, social media, and the web using AI.](/agentkit/connectors/supadatamcp/) [OAuth 2.1/DCR](/agentkit/connectors/supadatamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/supermetrics.svg)](/agentkit/connectors/supermetricsmcp/) [Supermetrics MCP connector](/agentkit/connectors/supermetricsmcp/) [Connect to Supermetrics MCP to query marketing data, discover data sources, manage campaigns, and run analytics across your connected ad and analytics...](/agentkit/connectors/supermetricsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/supermetricsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/surveymonkey.svg)](/agentkit/connectors/surveymonkeymcp/) [SurveyMonkey MCP connector](/agentkit/connectors/surveymonkeymcp/) [Connect to SurveyMonkey to manage surveys, collect responses, and analyze results. Create and update surveys, manage collectors and contacts, and retrieve...](/agentkit/connectors/surveymonkeymcp/) [OAuth2.1/DCR](/agentkit/connectors/surveymonkeymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sybill.svg)](/agentkit/connectors/sybilmcp/) [Sybill MCP connector](/agentkit/connectors/sybilmcp/) [Connect to Sybill. Access AI-generated summaries of sales calls, deals, accounts, and conversations to accelerate B2B revenue workflows.](/agentkit/connectors/sybilmcp/) [OAuth 2.1/DCR](/agentkit/connectors/sybilmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/synthesize-bio.svg)](/agentkit/connectors/synthesizebiomcp/) [Synthesize Bio MCP connector](/agentkit/connectors/synthesizebiomcp/) [Connect to Synthesize Bio MCP. Run differential gene expression analysis, resolve sample metadata, and retrieve results and raw counts data from your AI...](/agentkit/connectors/synthesizebiomcp/) [OAuth 2.1/DCR](/agentkit/connectors/synthesizebiomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tableau.svg)](/agentkit/connectors/tableau/) [Tableau connector](/agentkit/connectors/tableau/) [Connect to Tableau Cloud or Tableau Server to browse workbooks, views, and data sources, export visualizations, and query underlying data.](/agentkit/connectors/tableau/) [API Key](/agentkit/connectors/tableau/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tango.svg)](/agentkit/connectors/tangomcp/) [Tango MCP connector](/agentkit/connectors/tangomcp/) [Connect to Tango MCP by makegov to search federal contracts, opportunities, vehicles, organizations, and protests, and pull competitive...](/agentkit/connectors/tangomcp/) [API Key](/agentkit/connectors/tangomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/testdino.svg)](/agentkit/connectors/testidinomcp/) [Testdino MCP connector](/agentkit/connectors/testidinomcp/) [TestDino is a Playwright test reporting and analytics platform that centralizes test data, detects flaky tests, and provides AI-powered debugging via MCP...](/agentkit/connectors/testidinomcp/) [OAuth2.1/DCR](/agentkit/connectors/testidinomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/twelvedata.svg)](/agentkit/connectors/twelvedatamcp/) [Twelve Data MCP connector](/agentkit/connectors/twelvedatamcp/) [Connect to Twelve Data MCP for real-time and historical financial market data, including stock, forex, crypto, and ETF prices, technical indicators...](/agentkit/connectors/twelvedatamcp/) [OAuth 2.1/DCR](/agentkit/connectors/twelvedatamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/typeform.svg)](/agentkit/connectors/typeformmcp/) [Typeform MCP connector](/agentkit/connectors/typeformmcp/) [Connect to Typeform MCP to create and manage forms, read responses, and manage workspaces, contacts, and webhooks directly from your AI workflows.](/agentkit/connectors/typeformmcp/) [OAuth 2.1/DCR](/agentkit/connectors/typeformmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zoominfo.svg)](/agentkit/connectors/zoominfo/) [ZoomInfo connector](/agentkit/connectors/zoominfo/) [Connect to ZoomInfo to search and enrich B2B contact and company data, access intent signals, discover technographic insights, and manage GTM Studio...](/agentkit/connectors/zoominfo/) [OAuth 2.0](/agentkit/connectors/zoominfo/) ## Automation [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/activepieces.svg)](/agentkit/connectors/activepiecesmcp/) [Activepieces MCP connector](/agentkit/connectors/activepiecesmcp/) [Connect to Activepieces MCP to trigger and manage no-code automation flows directly from your AI workflows.](/agentkit/connectors/activepiecesmcp/) [OAuth2.1/DCR](/agentkit/connectors/activepiecesmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airbyte.svg)](/agentkit/connectors/airbytemcp/) [Airbyte MCP connector](/agentkit/connectors/airbytemcp/) [Connect to Airbyte's MCP server to manage data pipelines, sources, destinations, and connections for your data integration workflows.](/agentkit/connectors/airbytemcp/) [OAuth2.1/DCR](/agentkit/connectors/airbytemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airparser.svg)](/agentkit/connectors/airparsermcp/) [Airparser MCP connector](/agentkit/connectors/airparsermcp/) [AI-powered document parser that extracts structured data from PDFs, emails, and other documents.](/agentkit/connectors/airparsermcp/) [OAuth2.1/DCR](/agentkit/connectors/airparsermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/anakin.svg)](/agentkit/connectors/anakinmcp/) [Anakin MCP connector](/agentkit/connectors/anakinmcp/) [Anakin is an AI platform and marketplace that lets you build, deploy, and access a wide range of AI tools and automated workflows. This MCP connector...](/agentkit/connectors/anakinmcp/) [OAuth2.1/DCR](/agentkit/connectors/anakinmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/anchorbrowser.svg)](/agentkit/connectors/anchorbrowsermcp/) [Anchor Browser MCP connector](/agentkit/connectors/anchorbrowsermcp/) [Connect to Anchor Browser MCP to run cloud browser automation, control live browser sessions, extract web data, and let AI agents browse and act on the...](/agentkit/connectors/anchorbrowsermcp/) [OAuth 2.1/DCR](/agentkit/connectors/anchorbrowsermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/apify.svg)](/agentkit/connectors/apifymcp/) [Apify MCP connector](/agentkit/connectors/apifymcp/) [Connect to Apify MCP to run web scraping, browser automation, and data extraction Actors directly from your AI workflows.](/agentkit/connectors/apifymcp/) [Bearer Token](/agentkit/connectors/apifymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/attention.svg)](/agentkit/connectors/attention/) [Attention connector](/agentkit/connectors/attention/) [Connect to Attention for AI insights, conversations, teams, and workflows](/agentkit/connectors/attention/) [API Key](/agentkit/connectors/attention/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/buildkite.svg)](/agentkit/connectors/buildkitemcp/) [Buildkite MCP connector](/agentkit/connectors/buildkitemcp/) [Connect to Buildkite MCP. Manage CI/CD pipelines, builds, agents, clusters, and test suites from your AI workflows.](/agentkit/connectors/buildkitemcp/) [OAuth 2.1/DCR](/agentkit/connectors/buildkitemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/catchr.svg)](/agentkit/connectors/catchrmcp/) [Catchr MCP connector](/agentkit/connectors/catchrmcp/) [Catchr is a data connector platform that syncs marketing and analytics data from ad platforms (Google Ads, Facebook Ads, etc.) to data warehouses and BI...](/agentkit/connectors/catchrmcp/) [OAuth2.1/DCR](/agentkit/connectors/catchrmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/chilipiper.svg)](/agentkit/connectors/chilipipermcp/) [ChiliPiper MCP connector](/agentkit/connectors/chilipipermcp/) [Connect to ChiliPiper MCP. Schedule meetings, manage routing rules, track distributions, and automate handoffs from your AI agents.](/agentkit/connectors/chilipipermcp/) [Bearer Token](/agentkit/connectors/chilipipermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/chorus.svg)](/agentkit/connectors/chorus/) [Chorus connector](/agentkit/connectors/chorus/) [Connect to Chorus.ai to sync calls, transcripts, conversation intelligence, and analytics.](/agentkit/connectors/chorus/) [Basic Auth](/agentkit/connectors/chorus/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clari.svg)](/agentkit/connectors/clari_copilot/) [Clari Copilot connector](/agentkit/connectors/clari_copilot/) [Connect to Clari Copilot for sales call transcripts, analytics, call data, and insights.](/agentkit/connectors/clari_copilot/) [API Key](/agentkit/connectors/clari_copilot/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clay.svg)](/agentkit/connectors/claymcp/) [Clay MCP connector](/agentkit/connectors/claymcp/) [Clay is a go-to-market (GTM) platform that unifies data sourcing from 150+ providers, AI-powered research agents, and workflow orchestration for sales and...](/agentkit/connectors/claymcp/) [OAuth 2.1/DCR](/agentkit/connectors/claymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/cloudflare.svg)](/agentkit/connectors/cloudflare/) [Cloudflare connector](/agentkit/connectors/cloudflare/) [Cloudflare is a cloud platform providing DNS management, CDN, security, and networking services. This connector enables automated management of zones, DNS...](/agentkit/connectors/cloudflare/) [OAuth 2.0](/agentkit/connectors/cloudflare/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/cloudflare.svg)](/agentkit/connectors/cloudfaremcp/) [Cloudflare MCP connector](/agentkit/connectors/cloudfaremcp/) [Connect to Cloudflare MCP to manage your Cloudflare account — execute API calls, search the OpenAPI spec, and interact with Workers, R2, D1, KV, and all...](/agentkit/connectors/cloudfaremcp/) [OAuth 2.1/DCR](/agentkit/connectors/cloudfaremcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/convertapi.svg)](/agentkit/connectors/convertapimcp/) [ConvertAPI MCP connector](/agentkit/connectors/convertapimcp/) [Connect to ConvertAPI MCP. Convert, merge, split, and transform files across 200+ formats including PDF, Word, Excel, images, and more.](/agentkit/connectors/convertapimcp/) [OAuth 2.1/DCR](/agentkit/connectors/convertapimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/databricks-1.svg)](/agentkit/connectors/databricksworkspace/) [Databricks Workspace connector](/agentkit/connectors/databricksworkspace/) [Connect to Databricks Workspace APIs using a Service Principal with OAuth 2.0 client credentials to manage clusters, jobs, notebooks, SQL, and more.](/agentkit/connectors/databricksworkspace/) [Service Principal (OAuth 2.0)](/agentkit/connectors/databricksworkspace/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/devin.svg)](/agentkit/connectors/devinmcp/) [Devin MCP connector](/agentkit/connectors/devinmcp/) [Connect to Devin MCP. Create and manage AI coding sessions, interact with Devin agents, manage playbooks and schedules, and browse repository wikis from...](/agentkit/connectors/devinmcp/) [Bearer Token](/agentkit/connectors/devinmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/docsautomator.svg)](/agentkit/connectors/docsautomatormcp/) [Docsautomator MCP connector](/agentkit/connectors/docsautomatormcp/) [Connect to DocsAutomator MCP. Generate documents and PDFs from templates using your data, automating document creation workflows.](/agentkit/connectors/docsautomatormcp/) [OAuth 2.1/DCR](/agentkit/connectors/docsautomatormcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/echtpost.svg)](/agentkit/connectors/echtpostmcp/) [Echtpost MCP connector](/agentkit/connectors/echtpostmcp/) [Connect to Echtpost MCP. Send physical postcards and letters programmatically via the Echtpost API.](/agentkit/connectors/echtpostmcp/) [OAuth 2.1/DCR](/agentkit/connectors/echtpostmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/exa.svg)](/agentkit/connectors/exa/) [Exa connector](/agentkit/connectors/exa/) [Connect to Exa to perform AI-powered semantic web search, crawl websites for structured content, get natural language answers from the web, run in-depth...](/agentkit/connectors/exa/) [API Key](/agentkit/connectors/exa/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fathom.svg)](/agentkit/connectors/fathom/) [Fathom connector](/agentkit/connectors/fathom/) [Connect to Fathom AI meeting assistant. Record, transcribe, and summarize meetings with AI-powered insights](/agentkit/connectors/fathom/) [API Key](/agentkit/connectors/fathom/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gong.svg)](/agentkit/connectors/gong/) [Gong connector](/agentkit/connectors/gong/) [Connect with Gong to sync calls, transcripts, insights, coaching and CRM activity](/agentkit/connectors/gong/) [OAuth 2.0](/agentkit/connectors/gong/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/granola.svg)](/agentkit/connectors/granola/) [Granola connector](/agentkit/connectors/granola/) [Connect to Granola to access AI-generated meeting notes, summaries, transcripts, and attendee data from your workspace. Granola automatically records and...](/agentkit/connectors/granola/) [Bearer Token](/agentkit/connectors/granola/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/granola.svg)](/agentkit/connectors/granolamcp/) [Granola MCP connector](/agentkit/connectors/granolamcp/) [Connect to Granola MCP using OAuth 2.1 with MCP discovery and dynamic client registration.](/agentkit/connectors/granolamcp/) [OAuth 2.1/DCR](/agentkit/connectors/granolamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jentic.svg)](/agentkit/connectors/jenticmcp/) [Jentic MCP connector](/agentkit/connectors/jenticmcp/) [Connect to Jentic MCP. Search available API actions, load execution details, manage credentials, and execute API operations from your AI workflows.](/agentkit/connectors/jenticmcp/) [OAuth 2.1/DCR](/agentkit/connectors/jenticmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jiminny.svg)](/agentkit/connectors/jiminny/) [Jiminny connector](/agentkit/connectors/jiminny/) [Connect with Jiminny to access call recordings, transcripts, coaching insights, and conversation intelligence data.](/agentkit/connectors/jiminny/) [Bearer Token](/agentkit/connectors/jiminny/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jotform.svg)](/agentkit/connectors/jotformmcp/) [Jotform MCP connector](/agentkit/connectors/jotformmcp/) [Connect to Jotform MCP. Create and edit forms, retrieve submissions, assign forms, and search assets from your AI workflows.](/agentkit/connectors/jotformmcp/) [OAuth 2.1/DCR](/agentkit/connectors/jotformmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/kit.svg)](/agentkit/connectors/kitmcp/) [Kit MCP connector](/agentkit/connectors/kitmcp/) [Connect to Kit MCP. Manage email subscribers, sequences, broadcasts, tags, and forms for your email marketing workflows.](/agentkit/connectors/kitmcp/) [OAuth 2.1/DCR](/agentkit/connectors/kitmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/launchdarkly.svg)](/agentkit/connectors/launchdarklymcp/) [LaunchDarkly MCP connector](/agentkit/connectors/launchdarklymcp/) [Connect to LaunchDarkly's hosted MCP server to manage feature flags, experiments, and release controls directly from your AI workflows.](/agentkit/connectors/launchdarklymcp/) [OAuth2.1/DCR](/agentkit/connectors/launchdarklymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mailchimp.svg)](/agentkit/connectors/mailchimp/) [Mailchimp connector](/agentkit/connectors/mailchimp/) [Connect to Mailchimp to manage audiences, campaigns, templates, automations, and reports.](/agentkit/connectors/mailchimp/) [OAuth 2.0](/agentkit/connectors/mailchimp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mailercloud.svg)](/agentkit/connectors/mailercloudmcp/) [Mailercloud MCP connector](/agentkit/connectors/mailercloudmcp/) [Connect to Mailer Cloud MCP. Manage email campaigns, subscriber lists, and automation workflows for your email marketing operations.](/agentkit/connectors/mailercloudmcp/) [OAuth 2.1/DCR](/agentkit/connectors/mailercloudmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mailerlite.svg)](/agentkit/connectors/mailerlitemcp/) [Mailerlite MCP connector](/agentkit/connectors/mailerlitemcp/) [Connect to MailerLite MCP. Manage email campaigns, subscribers, groups, automations, and forms from your AI workflows.](/agentkit/connectors/mailerlitemcp/) [OAuth 2.1/DCR](/agentkit/connectors/mailerlitemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/make.svg)](/agentkit/connectors/makemcp/) [Make MCP connector](/agentkit/connectors/makemcp/) [Connect to Make (formerly Integromat). Build, run, and manage automation scenarios, data stores, webhooks, and connections across thousands of apps from...](/agentkit/connectors/makemcp/) [OAuth 2.1/DCR](/agentkit/connectors/makemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/memberstack.svg)](/agentkit/connectors/memberstackmcp/) [Memberstack MCP connector](/agentkit/connectors/memberstackmcp/) [Connect to Memberstack MCP. Manage members, plans, form submissions, and permissions for your membership-based application.](/agentkit/connectors/memberstackmcp/) [OAuth 2.1/DCR](/agentkit/connectors/memberstackmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/netlify.svg)](/agentkit/connectors/netlifymcp/) [Netlify MCP connector](/agentkit/connectors/netlifymcp/) [Build, deploy, and manage Netlify projects — sites, functions, environment variables, forms, blobs, and edge functions — from AI agents via the Netlify...](/agentkit/connectors/netlifymcp/) [OAuth 2.1/DCR](/agentkit/connectors/netlifymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pandadoc.svg)](/agentkit/connectors/pandadocmcp/) [Pandadoc MCP connector](/agentkit/connectors/pandadocmcp/) [Connect to PandaDoc MCP. Create, send, and manage documents, templates, and e-signatures directly from your AI workflows.](/agentkit/connectors/pandadocmcp/) [OAuth 2.1/DCR](/agentkit/connectors/pandadocmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/phantombuster.svg)](/agentkit/connectors/phantombuster/) [PhantomBuster connector](/agentkit/connectors/phantombuster/) [Connect to PhantomBuster to automate web scraping and data extraction workflows. Launch, monitor, and manage automation agents that extract data from...](/agentkit/connectors/phantombuster/) [API Key](/agentkit/connectors/phantombuster/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/phantombuster.svg)](/agentkit/connectors/phantombustermcp/) [PhantomBuster MCP connector](/agentkit/connectors/phantombustermcp/) [Connect to PhantomBuster MCP server to launch and manage web automation agents, retrieve scraping outputs, manage leads, and explore workspace resources...](/agentkit/connectors/phantombustermcp/) [OAuth 2.1/DCR](/agentkit/connectors/phantombustermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/postman.svg)](/agentkit/connectors/postmanmcp/) [Postman MCP connector](/agentkit/connectors/postmanmcp/) [Connect to the Postman MCP server to manage collections, workspaces, environments, and APIs directly from your AI workflows.](/agentkit/connectors/postmanmcp/) [OAuth 2.1/DCR](/agentkit/connectors/postmanmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/replit.svg)](/agentkit/connectors/replitmcp/) [Replit MCP connector](/agentkit/connectors/replitmcp/) [Connect to Replit MCP. Create, update, and inspect Replit apps from natural-language prompts, list your apps, and resolve apps by name from your AI...](/agentkit/connectors/replitmcp/) [OAuth 2.1/DCR](/agentkit/connectors/replitmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/salesloft.svg)](/agentkit/connectors/salesloft/) [Salesloft connector](/agentkit/connectors/salesloft/) [Connect with Salesloft to manage people, cadences, accounts, activities, emails, calls, and notes](/agentkit/connectors/salesloft/) [OAuth 2.0](/agentkit/connectors/salesloft/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/signwell.svg)](/agentkit/connectors/signwell/) [SignWell connector](/agentkit/connectors/signwell/) [SignWell is an e-signature platform for sending, signing, and managing documents. Connect to create and send documents for signature, manage templates...](/agentkit/connectors/signwell/) [API Key](/agentkit/connectors/signwell/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/stackai.svg)](/agentkit/connectors/stackaimcp/) [Stack.ai MCP connector](/agentkit/connectors/stackaimcp/) [Connect to Stack AI MCP. Build, run, and manage AI workflow projects, search knowledge bases, list integration providers, and inspect execution traces...](/agentkit/connectors/stackaimcp/) [OAuth 2.1/DCR](/agentkit/connectors/stackaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/stripe.svg)](/agentkit/connectors/stripe/) [Stripe connector](/agentkit/connectors/stripe/) [Connect to Stripe to manage customers, payments, products, subscriptions, invoices, and financial data.](/agentkit/connectors/stripe/) [Bearer Token](/agentkit/connectors/stripe/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/stripe.svg)](/agentkit/connectors/stripemcp/) [Stripe MCP connector](/agentkit/connectors/stripemcp/) [Connect to Stripe MCP. Manage customers, invoices, subscriptions, refunds, disputes, and payments from your AI workflows.](/agentkit/connectors/stripemcp/) [OAuth 2.1/DCR](/agentkit/connectors/stripemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tally.svg)](/agentkit/connectors/tallymcp/) [Tally MCP connector](/agentkit/connectors/tallymcp/) [Connect to Tally MCP. Create and edit forms, manage submissions, and update styling and logic in your Tally workspace from AI workflows.](/agentkit/connectors/tallymcp/) [OAuth 2.1/DCR](/agentkit/connectors/tallymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tinyfish.svg)](/agentkit/connectors/tinyfishmcp/) [Tinyfish MCP connector](/agentkit/connectors/tinyfishmcp/) [Connect to Tinyfish MCP. Run browser-based web automations, fetch page content, and search the web using a real cloud Chrome browser.](/agentkit/connectors/tinyfishmcp/) [OAuth 2.1/DCR](/agentkit/connectors/tinyfishmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/twilio.svg)](/agentkit/connectors/twilio/) [Twilio connector](/agentkit/connectors/twilio/) [Connect to Twilio to send SMS/MMS messages, make voice calls, verify phone numbers with OTP, manage phone numbers, and access usage records.](/agentkit/connectors/twilio/) [Basic Auth](/agentkit/connectors/twilio/) [![](https://framerusercontent.com/images/Pl7PUhW6GIt6eumE6hy3eKACaA.png)](/agentkit/connectors/upstreammcp/) [Upstream MCP connector](/agentkit/connectors/upstreammcp/) [Connect to Upstream MCP to access AI-assistant tools and workflows, including inbox management, directly from your AI workflows.](/agentkit/connectors/upstreammcp/) [Bearer Token](/agentkit/connectors/upstreammcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zapier.svg)](/agentkit/connectors/zapiermcp/) [Zapier MCP connector](/agentkit/connectors/zapiermcp/) [Connect to Zapier MCP to automate workflows and integrate with thousands of apps directly from your AI agent.](/agentkit/connectors/zapiermcp/) [OAuth 2.1/DCR](/agentkit/connectors/zapiermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zenrows.svg)](/agentkit/connectors/zenrowsmcp/) [ZenRows MCP connector](/agentkit/connectors/zenrowsmcp/) [Connect to ZenRows MCP. Scrape any webpage with anti-bot bypass, render JavaScript-heavy sites, and automate browsers through ZenRows' cloud...](/agentkit/connectors/zenrowsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/zenrowsmcp/) ## Calendar [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/cal.svg)](/agentkit/connectors/calmcp/) [Cal MCP connector](/agentkit/connectors/calmcp/) [Connect to Cal MCP. Manage bookings, event types, schedules, and availability from your AI workflows.](/agentkit/connectors/calmcp/) [OAuth 2.1/DCR](/agentkit/connectors/calmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/calendly.svg)](/agentkit/connectors/calendly/) [Calendly connector](/agentkit/connectors/calendly/) [Connect to Calendly. Access user profile, events, and scheduling workflows.](/agentkit/connectors/calendly/) [OAuth 2.0](/agentkit/connectors/calendly/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/calendly.svg)](/agentkit/connectors/calendlymcp/) [Calendly MCP connector](/agentkit/connectors/calendlymcp/) [Connect to the Calendly MCP server to manage scheduled events, invitees, event types, and availability directly from your AI workflows.](/agentkit/connectors/calendlymcp/) [OAuth 2.1/DCR](/agentkit/connectors/calendlymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/circleback.svg)](/agentkit/connectors/circlebackmcp/) [Circleback MCP connector](/agentkit/connectors/circlebackmcp/) [Circleback is an AI meeting notes and conversation intelligence platform. The Circleback MCP server provides a standardized interface that allows any...](/agentkit/connectors/circlebackmcp/) [OAuth 2.1/DCR](/agentkit/connectors/circlebackmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_calendar.svg)](/agentkit/connectors/googlecalendar/) [Google Calendar connector](/agentkit/connectors/googlecalendar/) [Google Calendar is Google's cloud-based calendar service that allows you to manage your events, appointments, and schedules from any computer or device...](/agentkit/connectors/googlecalendar/) [OAuth 2.0](/agentkit/connectors/googlecalendar/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_meet.svg)](/agentkit/connectors/googlemeet/) [Google Meet connector](/agentkit/connectors/googlemeet/) [Connect to Google Meet. Create and manage video meetings with powerful collaboration features](/agentkit/connectors/googlemeet/) [OAuth 2.0](/agentkit/connectors/googlemeet/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/microsoft365.svg)](/agentkit/connectors/microsoft365/) [Microsoft 365 connector](/agentkit/connectors/microsoft365/) [Connect to Microsoft 365. Unified access to Outlook, Excel, Word, OneNote, OneDrive, SharePoint, and Teams through Microsoft Graph API.](/agentkit/connectors/microsoft365/) [OAuth 2.0](/agentkit/connectors/microsoft365/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/outlook.svg)](/agentkit/connectors/outlook/) [Outlook connector](/agentkit/connectors/outlook/) [Connect to Microsoft Outlook. Manage emails, calendar events, contacts, and tasks](/agentkit/connectors/outlook/) [OAuth 2.0](/agentkit/connectors/outlook/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/planningcenter.svg)](/agentkit/connectors/planningcentermcp/) [Planning Center MCP connector](/agentkit/connectors/planningcentermcp/) [Planning Center is a church management platform with modules for people (contact database), giving, check-ins, services planning, groups, registrations...](/agentkit/connectors/planningcentermcp/) [OAuth 2.1/DCR](/agentkit/connectors/planningcentermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zoom.svg)](/agentkit/connectors/zoom/) [Zoom connector](/agentkit/connectors/zoom/) [Connect to Zoom. Schedule meetings, manage recordings, and handle video conferencing workflows](/agentkit/connectors/zoom/) [OAuth 2.0](/agentkit/connectors/zoom/) ## Collaboration [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/asana-n.svg)](/agentkit/connectors/asana/) [Asana connector](/agentkit/connectors/asana/) [Connect to Asana. Manage tasks, projects, teams, and workflow automation](/agentkit/connectors/asana/) [OAuth 2.0](/agentkit/connectors/asana/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/atlassian.svg)](/agentkit/connectors/atlassianmcp/) [Atlassian Rovo MCP connector](/agentkit/connectors/atlassianmcp/) [Connect to Atlassian Rovo MCP server to manage Jira issues, Confluence pages, and Compass components directly from your AI workflows.](/agentkit/connectors/atlassianmcp/) [OAuth 2.1/DCR](/agentkit/connectors/atlassianmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bitbucket.svg)](/agentkit/connectors/bitbucket/) [Bitbucket connector](/agentkit/connectors/bitbucket/) [Connect to Bitbucket. Manage repositories, pipelines, pull requests, and code collaboration.](/agentkit/connectors/bitbucket/) [OAuth 2.0](/agentkit/connectors/bitbucket/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/canva.svg)](/agentkit/connectors/canva/) [Canva connector](/agentkit/connectors/canva/) [Connect to Canva's Connect API to manage designs, assets, folders, brand templates, comments, autofills, exports, and analytics on the user's behalf via...](/agentkit/connectors/canva/) [OAuth 2.0](/agentkit/connectors/canva/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/claap.svg)](/agentkit/connectors/claapmcp/) [Claap MCP connector](/agentkit/connectors/claapmcp/) [Video collaboration platform for recording, sharing, and discussing async video clips — used for meeting recordings, product demos, feedback, and team...](/agentkit/connectors/claapmcp/) [OAuth2.1/DCR](/agentkit/connectors/claapmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clickup.svg)](/agentkit/connectors/clickup/) [ClickUp connector](/agentkit/connectors/clickup/) [Connect to ClickUp. Manage tasks, projects, workspaces, and team collaboration](/agentkit/connectors/clickup/) [OAuth 2.0](/agentkit/connectors/clickup/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/confluence.svg)](/agentkit/connectors/confluence/) [Confluence connector](/agentkit/connectors/confluence/) [Connect to Confluence. Manage spaces, pages, content, and team collaboration](/agentkit/connectors/confluence/) [OAuth 2.0](/agentkit/connectors/confluence/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/contentful.svg)](/agentkit/connectors/contentfulmcp/) [Contentful MCP connector](/agentkit/connectors/contentfulmcp/) [Connect to Contentful MCP. Manage spaces, entries, assets, content types, and taxonomies in your Contentful CMS from AI workflows.](/agentkit/connectors/contentfulmcp/) [OAuth 2.1/DCR](/agentkit/connectors/contentfulmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/discord.svg)](/agentkit/connectors/discordbot/) [Discord Bot connector](/agentkit/connectors/discordbot/) [Connect to Discord as a bot. Manage guilds, channels, members, messages, roles, webhooks, and more using a Discord Bot Token.](/agentkit/connectors/discordbot/) [API Key](/agentkit/connectors/discordbot/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/discord.svg)](/agentkit/connectors/discord/) [Discord connector](/agentkit/connectors/discord/) [Connect to Discord. Read user profile, guilds, roles, manage bots, and perform interactions.](/agentkit/connectors/discord/) [OAuth 2.0](/agentkit/connectors/discord/) [![](https://docs.excalidraw.com/img/logo.svg)](/agentkit/connectors/excalidrawmcp/) [Excalidraw MCP connector](/agentkit/connectors/excalidrawmcp/) [Excalidraw+ is a collaborative whiteboard and diagramming platform. The Excalidraw MCP server lets AI agents manage scenes, collections, workspaces...](/agentkit/connectors/excalidrawmcp/) [Bearer Token](/agentkit/connectors/excalidrawmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/figma.svg)](/agentkit/connectors/figma/) [Figma connector](/agentkit/connectors/figma/) [Connect to Figma to access user files, teams, projects, and design metadata via OAuth 2.0](/agentkit/connectors/figma/) [OAuth 2.0](/agentkit/connectors/figma/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fireflies.svg)](/agentkit/connectors/firefliesmcp/) [Fireflies MCP connector](/agentkit/connectors/firefliesmcp/) [Connect to Fireflies MCP. Search meeting transcripts, fetch recordings, manage channels, create soundbites, and retrieve analytics from your AI workflows.](/agentkit/connectors/firefliesmcp/) [OAuth 2.1/DCR](/agentkit/connectors/firefliesmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/github.png)](/agentkit/connectors/githubpat/) [GitHub (Personal Access Token) connector](/agentkit/connectors/githubpat/) [GitHub is a cloud-based Git repository hosting service that allows developers to store, manage, and track changes to their code. This variant...](/agentkit/connectors/githubpat/) [Bearer Token](/agentkit/connectors/githubpat/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/github.png)](/agentkit/connectors/github/) [Github connector](/agentkit/connectors/github/) [GitHub is a cloud-based Git repository hosting service that allows developers to store, manage, and track changes to their code.](/agentkit/connectors/github/) [OAuth 2.0](/agentkit/connectors/github/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/github.png)](/agentkit/connectors/githubmcp/) [GitHub MCP connector](/agentkit/connectors/githubmcp/) [Connect to GitHub MCP. Manage repositories, issues, pull requests, branches, and files directly from your AI workflows.](/agentkit/connectors/githubmcp/) [OAuth 2.1](/agentkit/connectors/githubmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gitlab.svg)](/agentkit/connectors/gitlab/) [GitLab connector](/agentkit/connectors/gitlab/) [Connect to GitLab to manage repositories, issues, merge requests, pipelines, CI/CD, users, groups, and DevOps workflows.](/agentkit/connectors/gitlab/) [OAuth 2.0](/agentkit/connectors/gitlab/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/grain.svg)](/agentkit/connectors/grainmcp/) [Grain MCP connector](/agentkit/connectors/grainmcp/) [Grain is a meeting recording and intelligence platform. Use this connector to search and retrieve meeting recordings, transcripts, notes, action items...](/agentkit/connectors/grainmcp/) [OAuth 2.1/DCR](/agentkit/connectors/grainmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/icepanel.png)](/agentkit/connectors/icepanelmcp/) [IcePanel MCP connector](/agentkit/connectors/icepanelmcp/) [Connect your IcePanel software architecture models to AI agents. Query and update your C4 model landscapes — systems, apps, components, connections, and...](/agentkit/connectors/icepanelmcp/) [OAuth 2.1/DCR](/agentkit/connectors/icepanelmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lucid.svg)](/agentkit/connectors/lucidmcp/) [Lucid MCP connector](/agentkit/connectors/lucidmcp/) [Connect to Lucid. Create and edit Lucidchart diagrams, Lucidspark boards, and Lucidscale visualizations from your AI workflows.](/agentkit/connectors/lucidmcp/) [OAuth 2.1/DCR](/agentkit/connectors/lucidmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/microsoft365.svg)](/agentkit/connectors/microsoft365/) [Microsoft 365 connector](/agentkit/connectors/microsoft365/) [Connect to Microsoft 365. Unified access to Outlook, Excel, Word, OneNote, OneDrive, SharePoint, and Teams through Microsoft Graph API.](/agentkit/connectors/microsoft365/) [OAuth 2.0](/agentkit/connectors/microsoft365/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/Miro.svg)](/agentkit/connectors/miro/) [Miro connector](/agentkit/connectors/miro/) [Miro is a visual collaboration platform for teams. Manage boards, sticky notes, shapes, cards, frames, connectors, images, and tags using the Miro REST...](/agentkit/connectors/miro/) [OAuth 2.0](/agentkit/connectors/miro/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/Miro.svg)](/agentkit/connectors/miromcp/) [Miro MCP connector](/agentkit/connectors/miromcp/) [Connect to Miro MCP to create and manage boards, frames, sticky notes, shapes, diagrams, and comments directly from your AI workflows.](/agentkit/connectors/miromcp/) [OAuth 2.1/DCR](/agentkit/connectors/miromcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/monday.svg)](/agentkit/connectors/mondaymcp/) [Monday MCP connector](/agentkit/connectors/mondaymcp/) [Connect to the monday.com MCP server to manage boards, items, columns, docs, and workflows directly from your AI agents.](/agentkit/connectors/mondaymcp/) [OAuth 2.1/DCR](/agentkit/connectors/mondaymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/monday.svg)](/agentkit/connectors/monday/) [Monday.com connector](/agentkit/connectors/monday/) [Connect to Monday.com. Manage boards, tasks, workflows, teams, and project collaboration](/agentkit/connectors/monday/) [OAuth 2.0](/agentkit/connectors/monday/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/nocodb.svg)](/agentkit/connectors/nocodbmcp/) [NocoDB MCP connector](/agentkit/connectors/nocodbmcp/) [Connect to NocoDB MCP. Create and manage databases, tables, records, views, and fields from your AI workflows.](/agentkit/connectors/nocodbmcp/) [OAuth 2.1/DCR](/agentkit/connectors/nocodbmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/notion.svg)](/agentkit/connectors/notion/) [Notion connector](/agentkit/connectors/notion/) [Connect to Notion workspace. Create, edit pages, manage databases, and collaborate on content](/agentkit/connectors/notion/) [OAuth 2.0](/agentkit/connectors/notion/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/notion.svg)](/agentkit/connectors/notionmcp/) [Notion MCP connector](/agentkit/connectors/notionmcp/) [Connect to Notion MCP. Create and update pages, databases, comments, and views from your AI workflows.](/agentkit/connectors/notionmcp/) [OAuth 2.1/DCR](/agentkit/connectors/notionmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/otterai.svg)](/agentkit/connectors/otteraimcp/) [OtterAI MCP connector](/agentkit/connectors/otteraimcp/) [Connect to OtterAI MCP. Search meeting recordings, fetch full transcripts, and retrieve user account info from your AI workflows.](/agentkit/connectors/otteraimcp/) [OAuth 2.1/DCR](/agentkit/connectors/otteraimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/slack.svg)](/agentkit/connectors/slack/) [Slack connector](/agentkit/connectors/slack/) [Connect to Slack workspace. Send Messages as Bots or on behalf of users](/agentkit/connectors/slack/) [OAuth 2.0](/agentkit/connectors/slack/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/slack.svg)](/agentkit/connectors/slackmcp/) [Slack MCP connector](/agentkit/connectors/slackmcp/) [Connect to Slack MCP. Send and read messages, search channels and users, manage canvases, and react to messages across your Slack workspace.](/agentkit/connectors/slackmcp/) [OAuth 2.1](/agentkit/connectors/slackmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/slite.svg)](/agentkit/connectors/slitemcp/) [Slite MCP connector](/agentkit/connectors/slitemcp/) [Connect to Slite MCP. Create and manage notes, channels, collections, and comments in Slite from AI workflows.](/agentkit/connectors/slitemcp/) [OAuth 2.1/DCR](/agentkit/connectors/slitemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/microsoft-teams.svg)](/agentkit/connectors/microsoftteams/) [Teams connector](/agentkit/connectors/microsoftteams/) [Connect to Microsoft Teams. Manage messages, channels, meetings, and team collaboration](/agentkit/connectors/microsoftteams/) [OAuth 2.0](/agentkit/connectors/microsoftteams/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/trello_n.svg)](/agentkit/connectors/trello/) [Trello connector](/agentkit/connectors/trello/) [Connect to Trello. Manage boards, cards, lists, and team collaboration workflows](/agentkit/connectors/trello/) [OAuth 1.0a](/agentkit/connectors/trello/) ## Communication [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/agentmail.svg)](/agentkit/connectors/agentmailmcp/) [Agentmail MCP connector](/agentkit/connectors/agentmailmcp/) [Connect to Agentmail MCP. Manage inboxes, send and receive email, handle drafts, threads, and attachments from your AI workflows.](/agentkit/connectors/agentmailmcp/) [OAuth 2.1/DCR](/agentkit/connectors/agentmailmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/brevo.svg)](/agentkit/connectors/brevomcp/) [Brevo MCP connector](/agentkit/connectors/brevomcp/) [Connect to Brevo MCP. Manage email and SMS campaigns, transactional emails, contacts, lists, automations, and loyalty programs from your AI workflows.](/agentkit/connectors/brevomcp/) [OAuth 2.1/DCR](/agentkit/connectors/brevomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/claap.svg)](/agentkit/connectors/claapmcp/) [Claap MCP connector](/agentkit/connectors/claapmcp/) [Video collaboration platform for recording, sharing, and discussing async video clips — used for meeting recordings, product demos, feedback, and team...](/agentkit/connectors/claapmcp/) [OAuth2.1/DCR](/agentkit/connectors/claapmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/close.svg)](/agentkit/connectors/close/) [Close connector](/agentkit/connectors/close/) [Connect to Close CRM. Manage leads, contacts, opportunities, tasks, activities, and sales workflows](/agentkit/connectors/close/) [OAuth 2.0](/agentkit/connectors/close/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/close.svg)](/agentkit/connectors/closemcp/) [Close MCP connector](/agentkit/connectors/closemcp/) [Close is a CRM and sales platform. The Close MCP server provides a standardized interface that allows any compatible AI model or agent to access Close CRM...](/agentkit/connectors/closemcp/) [OAuth 2.1/DCR](/agentkit/connectors/closemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/discord.svg)](/agentkit/connectors/discordbot/) [Discord Bot connector](/agentkit/connectors/discordbot/) [Connect to Discord as a bot. Manage guilds, channels, members, messages, roles, webhooks, and more using a Discord Bot Token.](/agentkit/connectors/discordbot/) [API Key](/agentkit/connectors/discordbot/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/discord.svg)](/agentkit/connectors/discord/) [Discord connector](/agentkit/connectors/discord/) [Connect to Discord. Read user profile, guilds, roles, manage bots, and perform interactions.](/agentkit/connectors/discord/) [OAuth 2.0](/agentkit/connectors/discord/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/echtpost.svg)](/agentkit/connectors/echtpostmcp/) [Echtpost MCP connector](/agentkit/connectors/echtpostmcp/) [Connect to Echtpost MCP. Send physical postcards and letters programmatically via the Echtpost API.](/agentkit/connectors/echtpostmcp/) [OAuth 2.1/DCR](/agentkit/connectors/echtpostmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fathom.svg)](/agentkit/connectors/fathom/) [Fathom connector](/agentkit/connectors/fathom/) [Connect to Fathom AI meeting assistant. Record, transcribe, and summarize meetings with AI-powered insights](/agentkit/connectors/fathom/) [API Key](/agentkit/connectors/fathom/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fathom.svg)](/agentkit/connectors/fathommcp/) [Fathom MCP connector](/agentkit/connectors/fathommcp/) [Connect to Fathom MCP to access AI meeting notes, summaries, transcripts, and recordings from your AI workflows.](/agentkit/connectors/fathommcp/) [OAuth 2.1/DCR](/agentkit/connectors/fathommcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/freshdesk.png)](/agentkit/connectors/freshdesk/) [Freshdesk connector](/agentkit/connectors/freshdesk/) [Connect to Freshdesk. Manage tickets, contacts, companies, and customer support workflows](/agentkit/connectors/freshdesk/) [Basic Auth](/agentkit/connectors/freshdesk/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gmail.svg)](/agentkit/connectors/gmail/) [Gmail connector](/agentkit/connectors/gmail/) [Gmail is Google's cloud based email service that allows you to access your messages from any computer or device with just a web browser.](/agentkit/connectors/gmail/) [OAuth 2.0](/agentkit/connectors/gmail/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_calendar.svg)](/agentkit/connectors/googlecalendar/) [Google Calendar connector](/agentkit/connectors/googlecalendar/) [Google Calendar is Google's cloud-based calendar service that allows you to manage your events, appointments, and schedules from any computer or device...](/agentkit/connectors/googlecalendar/) [OAuth 2.0](/agentkit/connectors/googlecalendar/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_meet.svg)](/agentkit/connectors/googlemeet/) [Google Meet connector](/agentkit/connectors/googlemeet/) [Connect to Google Meet. Create and manage video meetings with powerful collaboration features](/agentkit/connectors/googlemeet/) [OAuth 2.0](/agentkit/connectors/googlemeet/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google.svg)](/agentkit/connectors/googledwd/) [Google Workspace (DWD) connector](/agentkit/connectors/googledwd/) [Connect to Google Workspace APIs (Gmail, Drive, Docs, Sheets, Slides, Forms) using a GCP service account with Domain-Wide Delegation for server-to-server...](/agentkit/connectors/googledwd/) [Service Account (DWD)](/agentkit/connectors/googledwd/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gorgias.svg)](/agentkit/connectors/gorgiasmcp/) [Gorgias MCP connector](/agentkit/connectors/gorgiasmcp/) [Customer support helpdesk for e-commerce brands. Centralizes conversations from email, chat, social media, and SMS with ticket management and automation.](/agentkit/connectors/gorgiasmcp/) [OAuth2.1/DCR](/agentkit/connectors/gorgiasmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/granola.svg)](/agentkit/connectors/granola/) [Granola connector](/agentkit/connectors/granola/) [Connect to Granola to access AI-generated meeting notes, summaries, transcripts, and attendee data from your workspace. Granola automatically records and...](/agentkit/connectors/granola/) [Bearer Token](/agentkit/connectors/granola/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/granola.svg)](/agentkit/connectors/granolamcp/) [Granola MCP connector](/agentkit/connectors/granolamcp/) [Connect to Granola MCP using OAuth 2.1 with MCP discovery and dynamic client registration.](/agentkit/connectors/granolamcp/) [OAuth 2.1/DCR](/agentkit/connectors/granolamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/intercom.svg)](/agentkit/connectors/intercom/) [Intercom connector](/agentkit/connectors/intercom/) [Connect to Intercom. Send messages, manage conversations, and interact with users and contacts.](/agentkit/connectors/intercom/) [OAuth 2.0](/agentkit/connectors/intercom/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/linkedin.svg)](/agentkit/connectors/linkedin/) [LinkedIn connector](/agentkit/connectors/linkedin/) [Connect to LinkedIn to manage posts, ads, organizations, analytics, and professional profiles from your AI workflows.](/agentkit/connectors/linkedin/) [OAuth 2.0](/agentkit/connectors/linkedin/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mailerlite.svg)](/agentkit/connectors/mailerlitemcp/) [Mailerlite MCP connector](/agentkit/connectors/mailerlitemcp/) [Connect to MailerLite MCP. Manage email campaigns, subscribers, groups, automations, and forms from your AI workflows.](/agentkit/connectors/mailerlitemcp/) [OAuth 2.1/DCR](/agentkit/connectors/mailerlitemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mailgun.svg)](/agentkit/connectors/mailgun/) [Mailgun connector](/agentkit/connectors/mailgun/) [Connect to Mailgun to send transactional and marketing email, manage domains and DNS/DKIM security, mailing lists, suppressions (bounces, complaints...](/agentkit/connectors/mailgun/) [API Key](/agentkit/connectors/mailgun/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mailtrap.svg)](/agentkit/connectors/mailtrap/) [Mailtrap connector](/agentkit/connectors/mailtrap/) [Mailtrap is an email delivery platform for developers that provides transactional and bulk email sending, email sandbox testing, and deliverability tools....](/agentkit/connectors/mailtrap/) [Bearer Token](/agentkit/connectors/mailtrap/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/microsoft365.svg)](/agentkit/connectors/microsoft365/) [Microsoft 365 connector](/agentkit/connectors/microsoft365/) [Connect to Microsoft 365. Unified access to Outlook, Excel, Word, OneNote, OneDrive, SharePoint, and Teams through Microsoft Graph API.](/agentkit/connectors/microsoft365/) [OAuth 2.0](/agentkit/connectors/microsoft365/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mixmax.svg)](/agentkit/connectors/mixmaxmcp/) [Mixmax MCP connector](/agentkit/connectors/mixmaxmcp/) [Connect to Mixmax MCP. Manage email sequences, templates, contacts, and engagement analytics from your AI workflows.](/agentkit/connectors/mixmaxmcp/) [OAuth 2.1/DCR](/agentkit/connectors/mixmaxmcp/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/outlook.svg)](/agentkit/connectors/outlook/) [Outlook connector](/agentkit/connectors/outlook/) [Connect to Microsoft Outlook. Manage emails, calendar events, contacts, and tasks](/agentkit/connectors/outlook/) [OAuth 2.0](/agentkit/connectors/outlook/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/postmark.svg)](/agentkit/connectors/postmark/) [Postmark connector](/agentkit/connectors/postmark/) [Send and track transactional and broadcast email with Postmark. Manage templates, message streams, bounces, suppressions, webhooks, and delivery...](/agentkit/connectors/postmark/) [API Key](/agentkit/connectors/postmark/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/resend.svg)](/agentkit/connectors/resend/) [Resend connector](/agentkit/connectors/resend/) [Resend is an email API platform for developers. Send transactional and marketing emails, manage sending domains, contacts, audiences, broadcasts...](/agentkit/connectors/resend/) [Bearer Token](/agentkit/connectors/resend/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/salesloft.svg)](/agentkit/connectors/salesloft/) [Salesloft connector](/agentkit/connectors/salesloft/) [Connect with Salesloft to manage people, cadences, accounts, activities, emails, calls, and notes](/agentkit/connectors/salesloft/) [OAuth 2.0](/agentkit/connectors/salesloft/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sendgrid.svg)](/agentkit/connectors/sendgrid/) [SendGrid connector](/agentkit/connectors/sendgrid/) [Connect to Twilio SendGrid to send transactional and marketing email at scale, manage templates, contacts, lists, segments, and single sends, verify...](/agentkit/connectors/sendgrid/) [Bearer Token](/agentkit/connectors/sendgrid/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/servicenow.svg)](/agentkit/connectors/servicenow/) [ServiceNow connector](/agentkit/connectors/servicenow/) [Connect to ServiceNow. Manage incidents, service requests, CMDB, and IT service management workflows](/agentkit/connectors/servicenow/) [OAuth 2.0](/agentkit/connectors/servicenow/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/slack.svg)](/agentkit/connectors/slack/) [Slack connector](/agentkit/connectors/slack/) [Connect to Slack workspace. Send Messages as Bots or on behalf of users](/agentkit/connectors/slack/) [OAuth 2.0](/agentkit/connectors/slack/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/slack.svg)](/agentkit/connectors/slackmcp/) [Slack MCP connector](/agentkit/connectors/slackmcp/) [Connect to Slack MCP. Send and read messages, search channels and users, manage canvases, and react to messages across your Slack workspace.](/agentkit/connectors/slackmcp/) [OAuth 2.1](/agentkit/connectors/slackmcp/) [![](https://dac-static.atlassian.com/_static/Statuspage-blue.svg)](/agentkit/connectors/statuspage/) [Statuspage connector](/agentkit/connectors/statuspage/) [Connect to Statuspage. Manage status pages, incidents, components, component groups, subscribers, metrics, and page access permissions.](/agentkit/connectors/statuspage/) [API Key](/agentkit/connectors/statuspage/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/microsoft-teams.svg)](/agentkit/connectors/microsoftteams/) [Teams connector](/agentkit/connectors/microsoftteams/) [Connect to Microsoft Teams. Manage messages, channels, meetings, and team collaboration](/agentkit/connectors/microsoftteams/) [OAuth 2.0](/agentkit/connectors/microsoftteams/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/telnyx.svg)](/agentkit/connectors/telnyxmcp/) [Telnyx MCP connector](/agentkit/connectors/telnyxmcp/) [Telnyx is a communications platform for voice, messaging, and AI. This MCP connector lets AI agents manage phone numbers, send SMS and MMS, place and...](/agentkit/connectors/telnyxmcp/) [OAuth 2.1/DCR](/agentkit/connectors/telnyxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/twilio.svg)](/agentkit/connectors/twilio/) [Twilio connector](/agentkit/connectors/twilio/) [Connect to Twilio to send SMS/MMS messages, make voice calls, verify phone numbers with OTP, manage phone numbers, and access usage records.](/agentkit/connectors/twilio/) [Basic Auth](/agentkit/connectors/twilio/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/X.svg)](/agentkit/connectors/twitter/) [Twitter / X connector](/agentkit/connectors/twitter/) [Connect to Twitter. Read and write Tweets, read users, manage follows, bookmarks, etc.](/agentkit/connectors/twitter/) [Bearer Token](/agentkit/connectors/twitter/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/vapi.svg)](/agentkit/connectors/vapimcp/) [Vapi MCP connector](/agentkit/connectors/vapimcp/) [Vapi is an AI-powered voice platform for building, testing, and deploying voice AI agents. This MCP connector enables AI agents to manage Vapi assistants...](/agentkit/connectors/vapimcp/) [Bearer Token](/agentkit/connectors/vapimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zendesk.svg)](/agentkit/connectors/zendeskoauth/) [Zendesk (OAUTH) connector](/agentkit/connectors/zendeskoauth/) [Connect to Zendesk. Manage customer support tickets, users, organizations, and help desk operations](/agentkit/connectors/zendeskoauth/) [OAuth 2.0](/agentkit/connectors/zendeskoauth/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zendesk.svg)](/agentkit/connectors/zendesk/) [Zendesk connector](/agentkit/connectors/zendesk/) [Connect to Zendesk. Manage customer support tickets, users, organizations, and help desk operations](/agentkit/connectors/zendesk/) [API KEY](/agentkit/connectors/zendesk/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zoom.svg)](/agentkit/connectors/zoom/) [Zoom connector](/agentkit/connectors/zoom/) [Connect to Zoom. Schedule meetings, manage recordings, and handle video conferencing workflows](/agentkit/connectors/zoom/) [OAuth 2.0](/agentkit/connectors/zoom/) ## CRM & Sales [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/affinity.svg)](/agentkit/connectors/affinity/) [Affinity connector](/agentkit/connectors/affinity/) [Connect to Affinity relationship intelligence CRM to manage deal flow, relationships, pipeline opportunities, and network connections for private capital...](/agentkit/connectors/affinity/) [Bearer Token](/agentkit/connectors/affinity/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/ahrefs.svg)](/agentkit/connectors/ahrefsmcp/) [Ahrefs MCP connector](/agentkit/connectors/ahrefsmcp/) [Connect to Ahrefs MCP to access SEO data including backlinks, keyword research, site audits, rank tracking, and web analytics directly from your AI...](/agentkit/connectors/ahrefsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/ahrefsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/apollo.svg)](/agentkit/connectors/apollo/) [Apollo connector](/agentkit/connectors/apollo/) [Connect to Apollo.io to search and enrich B2B contacts and accounts, manage CRM contacts, and automate outreach sequences.](/agentkit/connectors/apollo/) [OAuth 2.0](/agentkit/connectors/apollo/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/apollo.svg)](/agentkit/connectors/apollomcp/) [Apollo MCP connector](/agentkit/connectors/apollomcp/) [Connect to Apollo MCP to search B2B contacts, enrich people and organizations, manage CRM records, and enroll prospects in sequences.](/agentkit/connectors/apollomcp/) [OAuth 2.1/DCR](/agentkit/connectors/apollomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/attention.svg)](/agentkit/connectors/attention/) [Attention connector](/agentkit/connectors/attention/) [Connect to Attention for AI insights, conversations, teams, and workflows](/agentkit/connectors/attention/) [API Key](/agentkit/connectors/attention/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/attio.svg)](/agentkit/connectors/attio/) [Attio connector](/agentkit/connectors/attio/) [Connect to Attio CRM to manage contacts, companies, deals, notes, tasks, and lists with a modern relationship management platform.](/agentkit/connectors/attio/) [OAuth 2.0](/agentkit/connectors/attio/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/attio.svg)](/agentkit/connectors/attiomcp/) [Attio MCP connector](/agentkit/connectors/attiomcp/) [Connect to Attio MCP. Access and manage CRM records, lists, notes, tasks, emails, and workspace data across people, companies, and deals.](/agentkit/connectors/attiomcp/) [OAuth 2.1/DCR](/agentkit/connectors/attiomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bitly.svg)](/agentkit/connectors/bitlymcp/) [Bitly MCP connector](/agentkit/connectors/bitlymcp/) [Connect with Bitly MCP for URL shortening, link analytics, and branded links.](/agentkit/connectors/bitlymcp/) [OAuth 2.1/DCR](/agentkit/connectors/bitlymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bonsai.svg)](/agentkit/connectors/bonsaimcp/) [Bonsai MCP connector](/agentkit/connectors/bonsaimcp/) [Connect to Bonsai, the all-in-one business management platform for freelancers and agencies. Manage projects, tasks, CRM contacts, deals, invoices, and...](/agentkit/connectors/bonsaimcp/) [OAuth2.1/DCR](/agentkit/connectors/bonsaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/chilipiper.svg)](/agentkit/connectors/chilipipermcp/) [ChiliPiper MCP connector](/agentkit/connectors/chilipipermcp/) [Connect to ChiliPiper MCP. Schedule meetings, manage routing rules, track distributions, and automate handoffs from your AI agents.](/agentkit/connectors/chilipipermcp/) [Bearer Token](/agentkit/connectors/chilipipermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/chorus.svg)](/agentkit/connectors/chorus/) [Chorus connector](/agentkit/connectors/chorus/) [Connect to Chorus.ai to sync calls, transcripts, conversation intelligence, and analytics.](/agentkit/connectors/chorus/) [Basic Auth](/agentkit/connectors/chorus/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clari.svg)](/agentkit/connectors/clari_copilot/) [Clari Copilot connector](/agentkit/connectors/clari_copilot/) [Connect to Clari Copilot for sales call transcripts, analytics, call data, and insights.](/agentkit/connectors/clari_copilot/) [API Key](/agentkit/connectors/clari_copilot/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clarify.svg)](/agentkit/connectors/clarifymcp/) [Clarify MCP connector](/agentkit/connectors/clarifymcp/) [Connect to Clarify MCP to manage CRM records, leads, campaigns, lists, and analytics directly from your AI workflows.](/agentkit/connectors/clarifymcp/) [OAuth 2.1/DCR](/agentkit/connectors/clarifymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clay.svg)](/agentkit/connectors/claymcp/) [Clay MCP connector](/agentkit/connectors/claymcp/) [Clay is a go-to-market (GTM) platform that unifies data sourcing from 150+ providers, AI-powered research agents, and workflow orchestration for sales and...](/agentkit/connectors/claymcp/) [OAuth 2.1/DCR](/agentkit/connectors/claymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/close.svg)](/agentkit/connectors/close/) [Close connector](/agentkit/connectors/close/) [Connect to Close CRM. Manage leads, contacts, opportunities, tasks, activities, and sales workflows](/agentkit/connectors/close/) [OAuth 2.0](/agentkit/connectors/close/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/close.svg)](/agentkit/connectors/closemcp/) [Close MCP connector](/agentkit/connectors/closemcp/) [Close is a CRM and sales platform. The Close MCP server provides a standardized interface that allows any compatible AI model or agent to access Close CRM...](/agentkit/connectors/closemcp/) [OAuth 2.1/DCR](/agentkit/connectors/closemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/commonroom.svg)](/agentkit/connectors/commonroommcp/) [Commonroom MCP connector](/agentkit/connectors/commonroommcp/) [Connect to Common Room MCP to manage community members, objects, and feedback data directly from your AI workflows.](/agentkit/connectors/commonroommcp/) [OAuth 2.1/DCR](/agentkit/connectors/commonroommcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/crustdata.svg)](/agentkit/connectors/crustdatamcp/) [Crustdata MCP connector](/agentkit/connectors/crustdatamcp/) [People and company intelligence platform for candidate sourcing, sales prospecting, and talent intelligence. Provides real-time data on professionals...](/agentkit/connectors/crustdatamcp/) [OAuth 2.1/DCR](/agentkit/connectors/crustdatamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/customerio.svg)](/agentkit/connectors/customeriomcp/) [Customer.io MCP connector](/agentkit/connectors/customeriomcp/) [Connect to Customer.io MCP to manage customers, campaigns, and events](/agentkit/connectors/customeriomcp/) [OAuth 2.1/DCR](/agentkit/connectors/customeriomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dropcontact.svg)](/agentkit/connectors/dropcontactmcp/) [Dropcontact MCP connector](/agentkit/connectors/dropcontactmcp/) [B2B contact enrichment and email verification platform that finds, verifies, and enriches professional email addresses and company data.](/agentkit/connectors/dropcontactmcp/) [OAuth 2.1/DCR](/agentkit/connectors/dropcontactmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dynamo.svg)](/agentkit/connectors/dynamo/) [Dynamo Software connector](/agentkit/connectors/dynamo/) [Connect to Dynamo Software API to access investment management, CRM, and reporting data.](/agentkit/connectors/dynamo/) [Bearer Token](/agentkit/connectors/dynamo/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/evertrace.png)](/agentkit/connectors/evertrace/) [Evertrace AI connector](/agentkit/connectors/evertrace/) [Connect to evertrace.ai to search and manage talent signals, saved searches, and lists. Access rich professional profiles with scoring, experiences, and...](/agentkit/connectors/evertrace/) [Bearer Token](/agentkit/connectors/evertrace/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/folk.svg)](/agentkit/connectors/folkmcp/) [Folk MCP connector](/agentkit/connectors/folkmcp/) [Folk is a collaborative CRM that helps teams manage contacts, track relationships, and run outreach — all in one workspace.](/agentkit/connectors/folkmcp/) [OAuth 2.1/DCR](/agentkit/connectors/folkmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fullenrich.svg)](/agentkit/connectors/fullenrichmcp/) [Fullenrich MCP connector](/agentkit/connectors/fullenrichmcp/) [Connect to FullEnrich MCP. Enrich contacts with verified email addresses and phone numbers using waterfall enrichment across multiple data providers.](/agentkit/connectors/fullenrichmcp/) [OAuth 2.1/DCR](/agentkit/connectors/fullenrichmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gainsight.svg)](/agentkit/connectors/gainsight/) [Gainsight connector](/agentkit/connectors/gainsight/) [Connect to Gainsight Customer Success to manage companies, contacts, calls to action, success plans, timeline activities, and custom objects. Power...](/agentkit/connectors/gainsight/) [API Key](/agentkit/connectors/gainsight/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gong.svg)](/agentkit/connectors/gong/) [Gong connector](/agentkit/connectors/gong/) [Connect with Gong to sync calls, transcripts, insights, coaching and CRM activity](/agentkit/connectors/gong/) [OAuth 2.0](/agentkit/connectors/gong/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gong.svg)](/agentkit/connectors/gongmcp/) [Gong MCP connector](/agentkit/connectors/gongmcp/) [Connect with Gong MCP to access calls, transcripts, insights, coaching, and sales engagement data via the Model Context Protocol](/agentkit/connectors/gongmcp/) [OAuth2.1](/agentkit/connectors/gongmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_ads.png)](/agentkit/connectors/google_ads/) [Google Ads connector](/agentkit/connectors/google_ads/) [Connect to Google Ads to manage advertising campaigns, analyze performance metrics, and optimize ad spending across Google's advertising platform](/agentkit/connectors/google_ads/) [OAuth 2.0](/agentkit/connectors/google_ads/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/heyreach.svg)](/agentkit/connectors/heyreach/) [HeyReach connector](/agentkit/connectors/heyreach/) [Connect to HeyReach to manage LinkedIn outreach campaigns, lead lists, and conversations. List campaigns, retrieve leads, monitor campaign progress, and...](/agentkit/connectors/heyreach/) [API Key](/agentkit/connectors/heyreach/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/hub_spot.svg)](/agentkit/connectors/hubspot/) [HubSpot connector](/agentkit/connectors/hubspot/) [Connect to HubSpot CRM. Manage contacts, deals, companies, and marketing automation](/agentkit/connectors/hubspot/) [OAuth 2.0](/agentkit/connectors/hubspot/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/hub_spot.svg)](/agentkit/connectors/hubspotmcp/) [HubSpot MCP connector](/agentkit/connectors/hubspotmcp/) [Connect to HubSpot MCP. Manage CRM contacts, companies, deals, landing pages, campaigns, and analytics from your AI workflows.](/agentkit/connectors/hubspotmcp/) [OAuth 2.1](/agentkit/connectors/hubspotmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jiminny.svg)](/agentkit/connectors/jiminny/) [Jiminny connector](/agentkit/connectors/jiminny/) [Connect with Jiminny to access call recordings, transcripts, coaching insights, and conversation intelligence data.](/agentkit/connectors/jiminny/) [Bearer Token](/agentkit/connectors/jiminny/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/klaviyo.svg)](/agentkit/connectors/klaviyomcp/) [Klaviyo MCP connector](/agentkit/connectors/klaviyomcp/) [Connect to Klaviyo MCP. Report, strategize & create with real-time Klaviyo data](/agentkit/connectors/klaviyomcp/) [OAuth 2.1/DCR](/agentkit/connectors/klaviyomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/leadboxer.svg)](/agentkit/connectors/leadboxermcp/) [LeadBoxer MCP connector](/agentkit/connectors/leadboxermcp/) [Connect to LeadBoxer MCP to identify anonymous website visitors and enrich them with firmographic data. LeadBoxer is a B2B lead generation and website...](/agentkit/connectors/leadboxermcp/) [OAuth 2.1/DCR](/agentkit/connectors/leadboxermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/leadfeeder.svg)](/agentkit/connectors/leadfeedermcp/) [Leadfeeder MCP connector](/agentkit/connectors/leadfeedermcp/) [Connect to Leadfeeder's MCP server to identify website visitors, track B2B leads, and surface company-level intent data directly from your AI workflows.](/agentkit/connectors/leadfeedermcp/) [OAuth2.1/DCR](/agentkit/connectors/leadfeedermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/leadiq.svg)](/agentkit/connectors/leadiq/) [LeadIQ connector](/agentkit/connectors/leadiq/) [Connect to LeadIQ to search and enrich B2B contacts and companies with verified emails, direct dials, and mobile numbers. Build prospect lists and power...](/agentkit/connectors/leadiq/) [API Key](/agentkit/connectors/leadiq/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/leadiq.svg)](/agentkit/connectors/leadiqmcp/) [LeadIQ MCP connector](/agentkit/connectors/leadiqmcp/) [Connect to LeadIQ via MCP to search and enrich B2B contacts and companies. Access real-time prospect data, company intelligence, and email/phone...](/agentkit/connectors/leadiqmcp/) [OAuth2.1/DCR](/agentkit/connectors/leadiqmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lemlist.svg)](/agentkit/connectors/lemlistmcp/) [Lemlist MCP connector](/agentkit/connectors/lemlistmcp/) [Connect to Lemlist MCP. Manage outbound sales campaigns, leads, email sequences, and LinkedIn outreach from your AI workflows.](/agentkit/connectors/lemlistmcp/) [OAuth 2.1/DCR](/agentkit/connectors/lemlistmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/linkedin.svg)](/agentkit/connectors/linkedin/) [LinkedIn connector](/agentkit/connectors/linkedin/) [Connect to LinkedIn to manage posts, ads, organizations, analytics, and professional profiles from your AI workflows.](/agentkit/connectors/linkedin/) [OAuth 2.0](/agentkit/connectors/linkedin/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lusha.svg)](/agentkit/connectors/lushamcp/) [Lusha MCP connector](/agentkit/connectors/lushamcp/) [Connect to Lusha MCP. Search and enrich B2B contacts and companies, find lookalikes, run prospecting searches, and access intent and activity signals from...](/agentkit/connectors/lushamcp/) [API Key](/agentkit/connectors/lushamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mixmax.svg)](/agentkit/connectors/mixmaxmcp/) [Mixmax MCP connector](/agentkit/connectors/mixmaxmcp/) [Connect to Mixmax MCP. Manage email sequences, templates, contacts, and engagement analytics from your AI workflows.](/agentkit/connectors/mixmaxmcp/) [OAuth 2.1/DCR](/agentkit/connectors/mixmaxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/outreach.png)](/agentkit/connectors/outreach/) [Outreach connector](/agentkit/connectors/outreach/) [Connect with Outreach to manage prospects, accounts, sequences, emails, calls, and sales engagement workflows.](/agentkit/connectors/outreach/) [OAuth 2.0](/agentkit/connectors/outreach/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pipedrive.svg)](/agentkit/connectors/pipedrive/) [Pipedrive connector](/agentkit/connectors/pipedrive/) [Connect to Pipedrive CRM. Manage deals, contacts, organizations, activities, leads, and notes to streamline your sales pipeline.](/agentkit/connectors/pipedrive/) [OAuth 2.0](/agentkit/connectors/pipedrive/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pipedrive.svg)](/agentkit/connectors/pipedrivemcp/) [Pipedrive MCP connector](/agentkit/connectors/pipedrivemcp/) [Connect to Pipedrive CRM via MCP to manage deals, contacts, organizations, leads, activities, and notes directly from your AI workflows.](/agentkit/connectors/pipedrivemcp/) [OAuth2.1/DCR](/agentkit/connectors/pipedrivemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/planningcenter.svg)](/agentkit/connectors/planningcentermcp/) [Planning Center MCP connector](/agentkit/connectors/planningcentermcp/) [Planning Center is a church management platform with modules for people (contact database), giving, check-ins, services planning, groups, registrations...](/agentkit/connectors/planningcentermcp/) [OAuth 2.1/DCR](/agentkit/connectors/planningcentermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/revealedai.svg)](/agentkit/connectors/revealedaimcp/) [Revealed AI MCP connector](/agentkit/connectors/revealedaimcp/) [Connect to Revealed AI. Track account signals, buyer personas, and people changes to surface timely outreach actions and account intelligence for B2B...](/agentkit/connectors/revealedaimcp/) [OAuth 2.1/DCR](/agentkit/connectors/revealedaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sales_force.svg)](/agentkit/connectors/salesforce/) [Salesforce connector](/agentkit/connectors/salesforce/) [Connect to Salesforce CRM. Manage leads, opportunities, accounts, and customer relationships](/agentkit/connectors/salesforce/) [OAuth 2.0](/agentkit/connectors/salesforce/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/salesloft.svg)](/agentkit/connectors/salesloft/) [Salesloft connector](/agentkit/connectors/salesloft/) [Connect with Salesloft to manage people, cadences, accounts, activities, emails, calls, and notes](/agentkit/connectors/salesloft/) [OAuth 2.0](/agentkit/connectors/salesloft/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/storeleads.svg)](/agentkit/connectors/storeleadsmcp/) [StoreLeads MCP connector](/agentkit/connectors/storeleadsmcp/) [Connect to StoreLeads MCP to discover, search, and analyze e-commerce stores and their technology stack from your AI workflows.](/agentkit/connectors/storeleadsmcp/) [Bearer Token](/agentkit/connectors/storeleadsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/supermetrics.svg)](/agentkit/connectors/supermetricsmcp/) [Supermetrics MCP connector](/agentkit/connectors/supermetricsmcp/) [Connect to Supermetrics MCP to query marketing data, discover data sources, manage campaigns, and run analytics across your connected ad and analytics...](/agentkit/connectors/supermetricsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/supermetricsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sybill.svg)](/agentkit/connectors/sybilmcp/) [Sybill MCP connector](/agentkit/connectors/sybilmcp/) [Connect to Sybill. Access AI-generated summaries of sales calls, deals, accounts, and conversations to accelerate B2B revenue workflows.](/agentkit/connectors/sybilmcp/) [OAuth 2.1/DCR](/agentkit/connectors/sybilmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/vibeprospecting.svg)](/agentkit/connectors/vibeprospectingmcp/) [Vibe Prospecting MCP connector](/agentkit/connectors/vibeprospectingmcp/) [Connect to Vibe Prospecting by Explorium to build B2B lead lists, research companies and prospects, enrich contacts, and personalize outreach from your AI...](/agentkit/connectors/vibeprospectingmcp/) [OAuth 2.1/DCR](/agentkit/connectors/vibeprospectingmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zoho_crm.svg)](/agentkit/connectors/zohocrm/) [Zoho CRM connector](/agentkit/connectors/zohocrm/) [Connect to Zoho CRM. Manage leads, contacts, accounts, deals, tasks, and other sales activities.](/agentkit/connectors/zohocrm/) [OAuth 2.0](/agentkit/connectors/zohocrm/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zoominfo.svg)](/agentkit/connectors/zoominfo/) [ZoomInfo connector](/agentkit/connectors/zoominfo/) [Connect to ZoomInfo to search and enrich B2B contact and company data, access intent signals, discover technographic insights, and manage GTM Studio...](/agentkit/connectors/zoominfo/) [OAuth 2.0](/agentkit/connectors/zoominfo/) ## Customer Support [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/devrev.svg)](/agentkit/connectors/devrevmcp/) [Dev Rev MCP connector](/agentkit/connectors/devrevmcp/) [Connect to DevRev MCP. Manage issues, work items, conversations, and customer data in the DevRev product development platform.](/agentkit/connectors/devrevmcp/) [Bearer Token](/agentkit/connectors/devrevmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/freshdesk.png)](/agentkit/connectors/freshdesk/) [Freshdesk connector](/agentkit/connectors/freshdesk/) [Connect to Freshdesk. Manage tickets, contacts, companies, and customer support workflows](/agentkit/connectors/freshdesk/) [Basic Auth](/agentkit/connectors/freshdesk/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gainsight.svg)](/agentkit/connectors/gainsight/) [Gainsight connector](/agentkit/connectors/gainsight/) [Connect to Gainsight Customer Success to manage companies, contacts, calls to action, success plans, timeline activities, and custom objects. Power...](/agentkit/connectors/gainsight/) [API Key](/agentkit/connectors/gainsight/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gorgias.svg)](/agentkit/connectors/gorgiasmcp/) [Gorgias MCP connector](/agentkit/connectors/gorgiasmcp/) [Customer support helpdesk for e-commerce brands. Centralizes conversations from email, chat, social media, and SMS with ticket management and automation.](/agentkit/connectors/gorgiasmcp/) [OAuth2.1/DCR](/agentkit/connectors/gorgiasmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/intercom.svg)](/agentkit/connectors/intercom/) [Intercom connector](/agentkit/connectors/intercom/) [Connect to Intercom. Send messages, manage conversations, and interact with users and contacts.](/agentkit/connectors/intercom/) [OAuth 2.0](/agentkit/connectors/intercom/) [![](https://wac-cdn.atlassian.com/dam/jcr:be09430e-3f78-4712-a953-ddcbe01ea541/jsd-icon.svg?cdnVersion=3478)](/agentkit/connectors/jiraservicemanagement/) [Jira Service Management connector](/agentkit/connectors/jiraservicemanagement/) [Connect to Jira Service Management. Manage customer requests, service desks, organizations, knowledge base articles, SLAs, and queues](/agentkit/connectors/jiraservicemanagement/) [OAuth 2.0](/agentkit/connectors/jiraservicemanagement/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/memberstack.svg)](/agentkit/connectors/memberstackmcp/) [Memberstack MCP connector](/agentkit/connectors/memberstackmcp/) [Connect to Memberstack MCP. Manage members, plans, form submissions, and permissions for your membership-based application.](/agentkit/connectors/memberstackmcp/) [OAuth 2.1/DCR](/agentkit/connectors/memberstackmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/plain.svg)](/agentkit/connectors/plainmcp/) [Plain MCP connector](/agentkit/connectors/plainmcp/) [Connect to Plain MCP. Manage customer support threads, labels, tenants, Help Center articles, and thread field schemas directly from your AI workflows.](/agentkit/connectors/plainmcp/) [OAuth 2.1/DCR](/agentkit/connectors/plainmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pylon.svg)](/agentkit/connectors/pylonmcp/) [Pylon MCP connector](/agentkit/connectors/pylonmcp/) [Connect to Pylon MCP. Manage customer issues, accounts, projects, milestones, and tasks from your AI workflows.](/agentkit/connectors/pylonmcp/) [OAuth 2.1/DCR](/agentkit/connectors/pylonmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/servicenow.svg)](/agentkit/connectors/servicenow/) [ServiceNow connector](/agentkit/connectors/servicenow/) [Connect to ServiceNow. Manage incidents, service requests, CMDB, and IT service management workflows](/agentkit/connectors/servicenow/) [OAuth 2.0](/agentkit/connectors/servicenow/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zendesk.svg)](/agentkit/connectors/zendeskoauth/) [Zendesk (OAUTH) connector](/agentkit/connectors/zendeskoauth/) [Connect to Zendesk. Manage customer support tickets, users, organizations, and help desk operations](/agentkit/connectors/zendeskoauth/) [OAuth 2.0](/agentkit/connectors/zendeskoauth/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zendesk.svg)](/agentkit/connectors/zendesk/) [Zendesk connector](/agentkit/connectors/zendesk/) [Connect to Zendesk. Manage customer support tickets, users, organizations, and help desk operations](/agentkit/connectors/zendesk/) [API KEY](/agentkit/connectors/zendesk/) ## Databases [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airtable.svg)](/agentkit/connectors/airtablemcp/) [Airtable MCP connector](/agentkit/connectors/airtablemcp/) [Connect to Airtable MCP. Manage bases, tables, records, views, fields, and automations from your AI workflows.](/agentkit/connectors/airtablemcp/) [OAuth 2.1/DCR](/agentkit/connectors/airtablemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/redshift.svg)](/agentkit/connectors/redshift/) [AWS Redshift connector](/agentkit/connectors/redshift/) [Connect Amazon Redshift to Scalekit with the Trusted IDP flow so agents run SQL over federated AWS credentials, with no long-lived keys stored.](/agentkit/connectors/redshift/) [Trusted IDP](/agentkit/connectors/redshift/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bigquery.svg)](/agentkit/connectors/bigqueryserviceaccount/) [BigQuery (Service Account) connector](/agentkit/connectors/bigqueryserviceaccount/) [Connect to Google BigQuery using a GCP service account for server-to-server authentication without user login.](/agentkit/connectors/bigqueryserviceaccount/) [Service Account](/agentkit/connectors/bigqueryserviceaccount/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bitquery.svg)](/agentkit/connectors/bitquerymcp/) [Bitquery MCP connector](/agentkit/connectors/bitquerymcp/) [Connect to Bitquery MCP. Query on-chain DEX trading data, token prices, OHLCV series, trader profiles, and trending tokens across multiple blockchains...](/agentkit/connectors/bitquerymcp/) [OAuth 2.1/DCR](/agentkit/connectors/bitquerymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/candid.svg)](/agentkit/connectors/candidmcp/) [Candid MCP connector](/agentkit/connectors/candidmcp/) [Connect to Candid MCP. Search nonprofit organizations, explore philanthropic data, and classify social sector activities using Candid's knowledge base.](/agentkit/connectors/candidmcp/) [OAuth 2.1/DCR](/agentkit/connectors/candidmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clickhouse.svg)](/agentkit/connectors/clickhouse/) [Clickhouse MCP connector](/agentkit/connectors/clickhouse/) [Connect to ClickHouse MCP to query, analyze, and manage your ClickHouse databases directly from your AI workflows.](/agentkit/connectors/clickhouse/) [OAuth 2.1/DCR](/agentkit/connectors/clickhouse/) [![](https://platform.cognee.ai/icon.svg?icon.3c7f72a5.svg)](/agentkit/connectors/cognee/) [Cognee connector](/agentkit/connectors/cognee/) [Connect to Cognee, an AI memory engine for agents. Remember data into a knowledge graph, recall it with semantic search, improve stored memory, and forget...](/agentkit/connectors/cognee/) [API Key](/agentkit/connectors/cognee/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/databricks-1.svg)](/agentkit/connectors/databricksworkspace/) [Databricks Workspace connector](/agentkit/connectors/databricksworkspace/) [Connect to Databricks Workspace APIs using a Service Principal with OAuth 2.0 client credentials to manage clusters, jobs, notebooks, SQL, and more.](/agentkit/connectors/databricksworkspace/) [Service Principal (OAuth 2.0)](/agentkit/connectors/databricksworkspace/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dynamo.svg)](/agentkit/connectors/dynamo/) [Dynamo Software connector](/agentkit/connectors/dynamo/) [Connect to Dynamo Software API to access investment management, CRM, and reporting data.](/agentkit/connectors/dynamo/) [Bearer Token](/agentkit/connectors/dynamo/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bigquery.svg)](/agentkit/connectors/bigquery/) [Google BigQuery connector](/agentkit/connectors/bigquery/) [BigQuery is Google Cloud’s fully-managed enterprise data warehouse for analytics at scale.](/agentkit/connectors/bigquery/) [OAuth 2.0](/agentkit/connectors/bigquery/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/googlelooker.svg)](/agentkit/connectors/googlelooker/) [Google Looker connector](/agentkit/connectors/googlelooker/) [Connect to Google Looker or self-hosted Looker Core. Browse dashboards, run Looks, query LookML models, and access BI data programmatically.](/agentkit/connectors/googlelooker/) [OAuth 2.0](/agentkit/connectors/googlelooker/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/legaldatahunter.svg)](/agentkit/connectors/legaldatahuntermcp/) [Legal Data Hunter MCP connector](/agentkit/connectors/legaldatahuntermcp/) [Connect to Legal Data Hunter MCP. Search and explore indexed legal data sources worldwide, tracking case law, courts, dockets, and legal data coverage...](/agentkit/connectors/legaldatahuntermcp/) [OAuth 2.1/DCR](/agentkit/connectors/legaldatahuntermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mem0.svg)](/agentkit/connectors/mem0mcp/) [Mem0 MCP connector](/agentkit/connectors/mem0mcp/) [Connect to Mem0 MCP. Store, search, and retrieve persistent memory for AI agents and applications using semantic search.](/agentkit/connectors/mem0mcp/) [OAuth 2.1/DCR](/agentkit/connectors/mem0mcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/motherduck.svg)](/agentkit/connectors/motherduckmcp/) [MotherDuck MCP connector](/agentkit/connectors/motherduckmcp/) [Connect to MotherDuck MCP. Query and analyze DuckDB databases, explore schemas, create visualizations, and automate data workflows from your AI workflows.](/agentkit/connectors/motherduckmcp/) [OAuth 2.1/DCR](/agentkit/connectors/motherduckmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/neon.svg)](/agentkit/connectors/neonmcp/) [Neon MCP connector](/agentkit/connectors/neonmcp/) [Connect to Neon MCP. Manage Neon serverless Postgres databases, projects, branches, and queries from your AI workflows.](/agentkit/connectors/neonmcp/) [OAuth 2.1/DCR](/agentkit/connectors/neonmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/nocodb.svg)](/agentkit/connectors/nocodbmcp/) [NocoDB MCP connector](/agentkit/connectors/nocodbmcp/) [Connect to NocoDB MCP. Create and manage databases, tables, records, views, and fields from your AI workflows.](/agentkit/connectors/nocodbmcp/) [OAuth 2.1/DCR](/agentkit/connectors/nocodbmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/planetscale.svg)](/agentkit/connectors/planetscalemcp/) [Planet Scale MCP connector](/agentkit/connectors/planetscalemcp/) [Connect to PlanetScale MCP. Run SQL queries, inspect database branches and schemas, get query performance insights, and manage organizations and invoices...](/agentkit/connectors/planetscalemcp/) [OAuth 2.1/DCR](/agentkit/connectors/planetscalemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/prisma.svg)](/agentkit/connectors/prismamcp/) [Prisma MCP connector](/agentkit/connectors/prismamcp/) [Connect to Prisma MCP. Manage Prisma Postgres databases, run SQL queries, handle backups, and manage connection strings from your AI workflows.](/agentkit/connectors/prismamcp/) [OAuth 2.1/DCR](/agentkit/connectors/prismamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/snowflake.svg)](/agentkit/connectors/snowflake/) [Snowflake connector](/agentkit/connectors/snowflake/) [Connect to Snowflake to manage and analyze your data warehouse workloads](/agentkit/connectors/snowflake/) [OAuth 2.0](/agentkit/connectors/snowflake/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/snowflake.svg)](/agentkit/connectors/snowflakekeyauth/) [Snowflake Key Pair Auth connector](/agentkit/connectors/snowflakekeyauth/) [Connect to Snowflake via Public Private Key Pair to manage and analyze your data warehouse workloads](/agentkit/connectors/snowflakekeyauth/) [Bearer Token](/agentkit/connectors/snowflakekeyauth/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/supabase.svg)](/agentkit/connectors/supabase/) [Supabase connector](/agentkit/connectors/supabase/) [Connect to the Supabase Management API to manage organizations, projects, database branches, API keys, secrets, custom domains, network restrictions...](/agentkit/connectors/supabase/) [OAuth 2.0](/agentkit/connectors/supabase/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/synapse.svg)](/agentkit/connectors/synapsemcp/) [Synapse MCP connector](/agentkit/connectors/synapsemcp/) [Connect to the Synapse MCP server (Sage Bionetworks) to explore Synapse entities, annotations, provenance, and project structure, and to search...](/agentkit/connectors/synapsemcp/) [OAuth 2.1/DCR](/agentkit/connectors/synapsemcp/) ## Design [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/biorendermcp.svg)](/agentkit/connectors/biorendermcp/) [Bio Render MCP connector](/agentkit/connectors/biorendermcp/) [Connect to BioRender MCP. Search BioRender's scientific icon and figure template libraries to build publication-ready biological illustrations.](/agentkit/connectors/biorendermcp/) [OAuth 2.1/DCR](/agentkit/connectors/biorendermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/canva.svg)](/agentkit/connectors/canva/) [Canva connector](/agentkit/connectors/canva/) [Connect to Canva's Connect API to manage designs, assets, folders, brand templates, comments, autofills, exports, and analytics on the user's behalf via...](/agentkit/connectors/canva/) [OAuth 2.0](/agentkit/connectors/canva/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/eraser.svg)](/agentkit/connectors/erasermcp/) [Eraser MCP connector](/agentkit/connectors/erasermcp/) [Connect to Eraser MCP. Create and edit diagrams, flowcharts, and technical documentation using Eraser's AI-powered diagramming tools.](/agentkit/connectors/erasermcp/) [OAuth 2.1/DCR](/agentkit/connectors/erasermcp/) [![](https://docs.excalidraw.com/img/logo.svg)](/agentkit/connectors/excalidrawmcp/) [Excalidraw MCP connector](/agentkit/connectors/excalidrawmcp/) [Excalidraw+ is a collaborative whiteboard and diagramming platform. The Excalidraw MCP server lets AI agents manage scenes, collections, workspaces...](/agentkit/connectors/excalidrawmcp/) [Bearer Token](/agentkit/connectors/excalidrawmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/figma.svg)](/agentkit/connectors/figma/) [Figma connector](/agentkit/connectors/figma/) [Connect to Figma to access user files, teams, projects, and design metadata via OAuth 2.0](/agentkit/connectors/figma/) [OAuth 2.0](/agentkit/connectors/figma/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/kling.svg)](/agentkit/connectors/klingmcp/) [Kling AI MCP connector](/agentkit/connectors/klingmcp/) [Kling AI is a video and image generation platform. This MCP connector exposes Kling AI capabilities — including video generation and image generation —...](/agentkit/connectors/klingmcp/) [OAuth2.1/DCR](/agentkit/connectors/klingmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lucid.svg)](/agentkit/connectors/lucidmcp/) [Lucid MCP connector](/agentkit/connectors/lucidmcp/) [Connect to Lucid. Create and edit Lucidchart diagrams, Lucidspark boards, and Lucidscale visualizations from your AI workflows.](/agentkit/connectors/lucidmcp/) [OAuth 2.1/DCR](/agentkit/connectors/lucidmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/magicpatterns.svg)](/agentkit/connectors/magicpatternsmcp/) [Magic Patterns MCP connector](/agentkit/connectors/magicpatternsmcp/) [Connect to Magic Patterns, the AI-powered UI design tool. Generate, edit, and manage design components and artifacts from your AI workflows.](/agentkit/connectors/magicpatternsmcp/) [OAuth2.1/DCR](/agentkit/connectors/magicpatternsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/Miro.svg)](/agentkit/connectors/miro/) [Miro connector](/agentkit/connectors/miro/) [Miro is a visual collaboration platform for teams. Manage boards, sticky notes, shapes, cards, frames, connectors, images, and tags using the Miro REST...](/agentkit/connectors/miro/) [OAuth 2.0](/agentkit/connectors/miro/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/Miro.svg)](/agentkit/connectors/miromcp/) [Miro MCP connector](/agentkit/connectors/miromcp/) [Connect to Miro MCP to create and manage boards, frames, sticky notes, shapes, diagrams, and comments directly from your AI workflows.](/agentkit/connectors/miromcp/) [OAuth 2.1/DCR](/agentkit/connectors/miromcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mobbins.svg)](/agentkit/connectors/mobbinmcp/) [Mobbin MCP connector](/agentkit/connectors/mobbinmcp/) [Connect to Mobbin's MCP server to search real-world UI and UX design references from mobile apps, web apps, and websites using natural language. Returns...](/agentkit/connectors/mobbinmcp/) [OAuth2.1/DCR](/agentkit/connectors/mobbinmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/onepage.svg)](/agentkit/connectors/onepagemcp/) [Onepage MCP connector](/agentkit/connectors/onepagemcp/) [Onepage is a website builder platform. The MCP connector lets Claude create, edit, and manage Onepage websites and pages on behalf of the user.](/agentkit/connectors/onepagemcp/) [OAuth2.1/DCR](/agentkit/connectors/onepagemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/recraft.svg)](/agentkit/connectors/recraftmcp/) [Recraft AI MCP connector](/agentkit/connectors/recraftmcp/) [Connect to Recraft AI MCP. Generate AI-powered images, vectors, icons, and mockups from your AI agents using Recraft's creative design tools.](/agentkit/connectors/recraftmcp/) [OAuth 2.1/DCR](/agentkit/connectors/recraftmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/v0.svg)](/agentkit/connectors/v0mcp/) [v0 MCP connector](/agentkit/connectors/v0mcp/) [Connect to v0 by Vercel to generate and iterate on web app UIs from natural language. Create chats, send follow-up messages, and inspect v0 Platform chats...](/agentkit/connectors/v0mcp/) [Bearer Token](/agentkit/connectors/v0mcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/webflow.svg)](/agentkit/connectors/webflowmcp/) [Webflow MCP connector](/agentkit/connectors/webflowmcp/) [Connect to Webflow. Build and manage websites, pages, components, styles, assets, CMS collections, and site settings through the Webflow Designer and Data...](/agentkit/connectors/webflowmcp/) [OAuth 2.1/DCR](/agentkit/connectors/webflowmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/whimsical.svg)](/agentkit/connectors/whimsicalmcp/) [Whimsical MCP connector](/agentkit/connectors/whimsicalmcp/) [Connect to Whimsical MCP. Create and edit flowcharts, mind maps, wireframes, and docs, and manage boards, comments, and workspaces from your AI workflows.](/agentkit/connectors/whimsicalmcp/) [OAuth 2.1/DCR](/agentkit/connectors/whimsicalmcp/) ## Developer Tools [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airbyte.svg)](/agentkit/connectors/airbytemcp/) [Airbyte MCP connector](/agentkit/connectors/airbytemcp/) [Connect to Airbyte's MCP server to manage data pipelines, sources, destinations, and connections for your data integration workflows.](/agentkit/connectors/airbytemcp/) [OAuth2.1/DCR](/agentkit/connectors/airbytemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/alphaxiv.svg)](/agentkit/connectors/alphaxivmcp/) [AlphaXiv MCP connector](/agentkit/connectors/alphaxivmcp/) [Connect to AlphaXiv MCP to search and retrieve arXiv research papers, abstracts, authors, and citations from your AI workflows.](/agentkit/connectors/alphaxivmcp/) [OAuth 2.1/DCR](/agentkit/connectors/alphaxivmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/anchorbrowser.svg)](/agentkit/connectors/anchorbrowsermcp/) [Anchor Browser MCP connector](/agentkit/connectors/anchorbrowsermcp/) [Connect to Anchor Browser MCP to run cloud browser automation, control live browser sessions, extract web data, and let AI agents browse and act on the...](/agentkit/connectors/anchorbrowsermcp/) [OAuth 2.1/DCR](/agentkit/connectors/anchorbrowsermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/apify.svg)](/agentkit/connectors/apifymcp/) [Apify MCP connector](/agentkit/connectors/apifymcp/) [Connect to Apify MCP to run web scraping, browser automation, and data extraction Actors directly from your AI workflows.](/agentkit/connectors/apifymcp/) [Bearer Token](/agentkit/connectors/apifymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/appsignal.svg)](/agentkit/connectors/appsignalmcp/) [AppSignal MCP connector](/agentkit/connectors/appsignalmcp/) [AppSignal is an application monitoring and performance management platform providing error tracking, performance monitoring, and alerting for Ruby...](/agentkit/connectors/appsignalmcp/) [OAuth2.1/DCR](/agentkit/connectors/appsignalmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/axiom.svg)](/agentkit/connectors/axiommcp/) [Axiom MCP connector](/agentkit/connectors/axiommcp/) [Axiom is a cloud-native data analytics and observability platform for ingesting, storing, and querying logs, events, traces, and metrics at scale. The MCP...](/agentkit/connectors/axiommcp/) [OAuth2.1/DCR](/agentkit/connectors/axiommcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/betterstack.svg)](/agentkit/connectors/betterstackmcp/) [Betterstack MCP connector](/agentkit/connectors/betterstackmcp/) [Monitor uptime, manage logs, and respond to incidents with Better Stack's observability platform.](/agentkit/connectors/betterstackmcp/) [OAuth2.1/DCR](/agentkit/connectors/betterstackmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bitbucket.svg)](/agentkit/connectors/bitbucket/) [Bitbucket connector](/agentkit/connectors/bitbucket/) [Connect to Bitbucket. Manage repositories, pipelines, pull requests, and code collaboration.](/agentkit/connectors/bitbucket/) [OAuth 2.0](/agentkit/connectors/bitbucket/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bugsnag.svg)](/agentkit/connectors/bugsnagmcp/) [Bugsnag MCP connector](/agentkit/connectors/bugsnagmcp/) [Connect to Bugsnag MCP. Monitor errors, releases, traces, and span groups across your projects from your AI workflows.](/agentkit/connectors/bugsnagmcp/) [OAuth 2.1/DCR](/agentkit/connectors/bugsnagmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/buildkite.svg)](/agentkit/connectors/buildkitemcp/) [Buildkite MCP connector](/agentkit/connectors/buildkitemcp/) [Connect to Buildkite MCP. Manage CI/CD pipelines, builds, agents, clusters, and test suites from your AI workflows.](/agentkit/connectors/buildkitemcp/) [OAuth 2.1/DCR](/agentkit/connectors/buildkitemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/carbone.svg)](/agentkit/connectors/carboneiomcp/) [Carbone.io MCP connector](/agentkit/connectors/carboneiomcp/) [Connect to Carbone.io MCP. Upload templates, render documents by merging templates with JSON data, convert between 100+ formats, and manage template...](/agentkit/connectors/carboneiomcp/) [Bearer Token](/agentkit/connectors/carboneiomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clickhouse.svg)](/agentkit/connectors/clickhouse/) [Clickhouse MCP connector](/agentkit/connectors/clickhouse/) [Connect to ClickHouse MCP to query, analyze, and manage your ClickHouse databases directly from your AI workflows.](/agentkit/connectors/clickhouse/) [OAuth 2.1/DCR](/agentkit/connectors/clickhouse/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/cloudflare.svg)](/agentkit/connectors/cloudflare/) [Cloudflare connector](/agentkit/connectors/cloudflare/) [Cloudflare is a cloud platform providing DNS management, CDN, security, and networking services. This connector enables automated management of zones, DNS...](/agentkit/connectors/cloudflare/) [OAuth 2.0](/agentkit/connectors/cloudflare/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/cloudflare.svg)](/agentkit/connectors/cloudfaremcp/) [Cloudflare MCP connector](/agentkit/connectors/cloudfaremcp/) [Connect to Cloudflare MCP to manage your Cloudflare account — execute API calls, search the OpenAPI spec, and interact with Workers, R2, D1, KV, and all...](/agentkit/connectors/cloudfaremcp/) [OAuth 2.1/DCR](/agentkit/connectors/cloudfaremcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/cloudinary.svg)](/agentkit/connectors/cloudinarymcp/) [Cloudinary MCP connector](/agentkit/connectors/cloudinarymcp/) [Connects AI agents to Cloudinary's asset management platform, enabling upload, search, transformation, and organization of media assets through natural...](/agentkit/connectors/cloudinarymcp/) [OAuth2.1/DCR](/agentkit/connectors/cloudinarymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/cloudpress.svg)](/agentkit/connectors/cloudpressmcp/) [Cloudpress MCP connector](/agentkit/connectors/cloudpressmcp/) [Cloudpress is a managed WordPress hosting platform built for the AI era. Its MCP server lets AI agents manage sites, domains, DNS, security rules...](/agentkit/connectors/cloudpressmcp/) [OAuth 2.1/DCR](/agentkit/connectors/cloudpressmcp/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/context7.svg)](/agentkit/connectors/context7mcp/) [Context7 MCP connector](/agentkit/connectors/context7mcp/) [Connect to Context7 MCP to fetch up-to-date, version-specific library documentation and code examples directly from the source.](/agentkit/connectors/context7mcp/) [API Key](/agentkit/connectors/context7mcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/datadog.svg)](/agentkit/connectors/datadog/) [Datadog connector](/agentkit/connectors/datadog/) [Connect to Datadog to monitor metrics, logs, traces, dashboards, monitors, incidents, SLOs, synthetics, and security signals across your infrastructure.](/agentkit/connectors/datadog/) [API Key](/agentkit/connectors/datadog/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/devrev.svg)](/agentkit/connectors/devrevmcp/) [Dev Rev MCP connector](/agentkit/connectors/devrevmcp/) [Connect to DevRev MCP. Manage issues, work items, conversations, and customer data in the DevRev product development platform.](/agentkit/connectors/devrevmcp/) [Bearer Token](/agentkit/connectors/devrevmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/devin.svg)](/agentkit/connectors/devinmcp/) [Devin MCP connector](/agentkit/connectors/devinmcp/) [Connect to Devin MCP. Create and manage AI coding sessions, interact with Devin agents, manage playbooks and schedules, and browse repository wikis from...](/agentkit/connectors/devinmcp/) [Bearer Token](/agentkit/connectors/devinmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/eraser.svg)](/agentkit/connectors/erasermcp/) [Eraser MCP connector](/agentkit/connectors/erasermcp/) [Connect to Eraser MCP. Create and edit diagrams, flowcharts, and technical documentation using Eraser's AI-powered diagramming tools.](/agentkit/connectors/erasermcp/) [OAuth 2.1/DCR](/agentkit/connectors/erasermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/exa.svg)](/agentkit/connectors/examcp/) [Exa MCP connector](/agentkit/connectors/examcp/) [Connect to Exa MCP to perform AI-powered semantic web search, crawl websites for structured content, get natural language answers from the web, and run...](/agentkit/connectors/examcp/) [API Key](/agentkit/connectors/examcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/expo.svg)](/agentkit/connectors/expomcp/) [Expo MCP connector](/agentkit/connectors/expomcp/) [Expo is a platform for building universal React Native apps; its MCP server exposes developer services including EAS builds, submissions, and project...](/agentkit/connectors/expomcp/) [OAuth2.1/DCR](/agentkit/connectors/expomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/firecrawl.svg)](/agentkit/connectors/firecrawlmcp/) [Firecrawl MCP connector](/agentkit/connectors/firecrawlmcp/) [Connect to Firecrawl MCP. Scrape, crawl, search, extract structured data, and monitor websites using Firecrawl's AI-powered web scraping API.](/agentkit/connectors/firecrawlmcp/) [Bearer Token](/agentkit/connectors/firecrawlmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/github.png)](/agentkit/connectors/githubpat/) [GitHub (Personal Access Token) connector](/agentkit/connectors/githubpat/) [GitHub is a cloud-based Git repository hosting service that allows developers to store, manage, and track changes to their code. This variant...](/agentkit/connectors/githubpat/) [Bearer Token](/agentkit/connectors/githubpat/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/github.png)](/agentkit/connectors/github/) [Github connector](/agentkit/connectors/github/) [GitHub is a cloud-based Git repository hosting service that allows developers to store, manage, and track changes to their code.](/agentkit/connectors/github/) [OAuth 2.0](/agentkit/connectors/github/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/github.png)](/agentkit/connectors/githubmcp/) [GitHub MCP connector](/agentkit/connectors/githubmcp/) [Connect to GitHub MCP. Manage repositories, issues, pull requests, branches, and files directly from your AI workflows.](/agentkit/connectors/githubmcp/) [OAuth 2.1](/agentkit/connectors/githubmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gitlab.svg)](/agentkit/connectors/gitlab/) [GitLab connector](/agentkit/connectors/gitlab/) [Connect to GitLab to manage repositories, issues, merge requests, pipelines, CI/CD, users, groups, and DevOps workflows.](/agentkit/connectors/gitlab/) [OAuth 2.0](/agentkit/connectors/gitlab/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/globalping.svg)](/agentkit/connectors/globalpingmcp/) [Globalping MCP connector](/agentkit/connectors/globalpingmcp/) [Globalping is a global network measurement platform for running ping, traceroute, DNS lookup, HTTP, and MTR tests from hundreds of probe locations...](/agentkit/connectors/globalpingmcp/) [OAuth2.1/DCR](/agentkit/connectors/globalpingmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gocardless.svg)](/agentkit/connectors/gocardlessmcp/) [GoCardless MCP connector](/agentkit/connectors/gocardlessmcp/) [Connect to GoCardless MCP. Retrieve and list customers, mandates, payments, payouts, refunds, and subscriptions, and explore integration options from your...](/agentkit/connectors/gocardlessmcp/) [OAuth 2.1/DCR](/agentkit/connectors/gocardlessmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/greptile.svg)](/agentkit/connectors/greptilmcp/) [Greptile MCP connector](/agentkit/connectors/greptilmcp/) [AI-powered code search and understanding API that indexes GitHub and GitLab repositories, enabling natural language queries over codebases.](/agentkit/connectors/greptilmcp/) [OAuth2.1/DCR](/agentkit/connectors/greptilmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gtmetrix.svg)](/agentkit/connectors/gtmetrixmcp/) [GTmetrix MCP connector](/agentkit/connectors/gtmetrixmcp/) [Connect to GTmetrix MCP to analyze web page performance, run speed tests, monitor Core Web Vitals, and get actionable optimization recommendations...](/agentkit/connectors/gtmetrixmcp/) [OAuth 2.1/DCR](/agentkit/connectors/gtmetrixmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/hex.svg)](/agentkit/connectors/hexmcp/) [Hex MCP connector](/agentkit/connectors/hexmcp/) [Connect to Hex MCP. Create and continue data analysis threads, search projects, and query your data using natural language from your AI workflows.](/agentkit/connectors/hexmcp/) [OAuth 2.1/DCR](/agentkit/connectors/hexmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/huggingface.svg)](/agentkit/connectors/huggingfacemcp/) [Hugging face MCP connector](/agentkit/connectors/huggingfacemcp/) [Connect to Hugging Face MCP. Search and manage models, datasets, spaces, and collections on the Hugging Face Hub.](/agentkit/connectors/huggingfacemcp/) [OAuth 2.1/DCR](/agentkit/connectors/huggingfacemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/icepanel.png)](/agentkit/connectors/icepanelmcp/) [IcePanel MCP connector](/agentkit/connectors/icepanelmcp/) [Connect your IcePanel software architecture models to AI agents. Query and update your C4 model landscapes — systems, apps, components, connections, and...](/agentkit/connectors/icepanelmcp/) [OAuth 2.1/DCR](/agentkit/connectors/icepanelmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jam.svg)](/agentkit/connectors/jammcp/) [Jam MCP connector](/agentkit/connectors/jammcp/) [Connect to Jam MCP. Access bug reports, console logs, network requests, user events, and video transcripts from your AI workflows.](/agentkit/connectors/jammcp/) [OAuth 2.1/DCR](/agentkit/connectors/jammcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jentic.svg)](/agentkit/connectors/jenticmcp/) [Jentic MCP connector](/agentkit/connectors/jenticmcp/) [Connect to Jentic MCP. Search available API actions, load execution details, manage credentials, and execute API operations from your AI workflows.](/agentkit/connectors/jenticmcp/) [OAuth 2.1/DCR](/agentkit/connectors/jenticmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jira.svg)](/agentkit/connectors/jira/) [Jira connector](/agentkit/connectors/jira/) [Connect to Jira. Manage issues, projects, workflows, and agile development processes](/agentkit/connectors/jira/) [OAuth 2.0](/agentkit/connectors/jira/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/latch.svg)](/agentkit/connectors/latchbiomcp/) [Latch Bio MCP connector](/agentkit/connectors/latchbiomcp/) [Latch Bio is a cloud bioinformatics platform for running computational biology workflows. Its MCP server lets AI agents list and retrieve files, manage...](/agentkit/connectors/latchbiomcp/) [OAuth 2.1/DCR](/agentkit/connectors/latchbiomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/launchdarkly.svg)](/agentkit/connectors/launchdarklymcp/) [LaunchDarkly MCP connector](/agentkit/connectors/launchdarklymcp/) [Connect to LaunchDarkly's hosted MCP server to manage feature flags, experiments, and release controls directly from your AI workflows.](/agentkit/connectors/launchdarklymcp/) [OAuth2.1/DCR](/agentkit/connectors/launchdarklymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/linear.svg)](/agentkit/connectors/linear/) [Linear connector](/agentkit/connectors/linear/) [Connect to Linear. Manage issues, projects, sprints, and development workflows](/agentkit/connectors/linear/) [OAuth 2.0](/agentkit/connectors/linear/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/linear.svg)](/agentkit/connectors/linearmcp/) [Linear MCP connector](/agentkit/connectors/linearmcp/) [Connect to Linear's hosted MCP server to manage issues, projects, cycles, and comments directly from your AI workflows.](/agentkit/connectors/linearmcp/) [OAuth 2.1/DCR](/agentkit/connectors/linearmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/logrocket.svg)](/agentkit/connectors/logrocketmcp/) [LogRocket MCP connector](/agentkit/connectors/logrocketmcp/) [Connect to LogRocket to access session data, query analytics, investigate user-reported issues, and detect regressions directly from your AI workflows.](/agentkit/connectors/logrocketmcp/) [OAuth2.1/DCR](/agentkit/connectors/logrocketmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mailtrap.svg)](/agentkit/connectors/mailtrap/) [Mailtrap connector](/agentkit/connectors/mailtrap/) [Mailtrap is an email delivery platform for developers that provides transactional and bulk email sending, email sandbox testing, and deliverability tools....](/agentkit/connectors/mailtrap/) [Bearer Token](/agentkit/connectors/mailtrap/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/make.svg)](/agentkit/connectors/makemcp/) [Make MCP connector](/agentkit/connectors/makemcp/) [Connect to Make (formerly Integromat). Build, run, and manage automation scenarios, data stores, webhooks, and connections across thousands of apps from...](/agentkit/connectors/makemcp/) [OAuth 2.1/DCR](/agentkit/connectors/makemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mintlify.svg)](/agentkit/connectors/mintlifymcp/) [Mintlify MCP connector](/agentkit/connectors/mintlifymcp/) [Connect to Mintlify MCP. Read and edit documentation pages, manage navigation nodes, search content, and publish changes via pull requests from your AI...](/agentkit/connectors/mintlifymcp/) [OAuth 2.1/DCR](/agentkit/connectors/mintlifymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mux.svg)](/agentkit/connectors/muxmcp/) [Mux MCP connector](/agentkit/connectors/muxmcp/) [Mux is a video infrastructure platform for developers, providing APIs for video hosting, on-demand streaming, live streaming, and playback with analytics...](/agentkit/connectors/muxmcp/) [OAuth2.1/DCR](/agentkit/connectors/muxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/neon.svg)](/agentkit/connectors/neonmcp/) [Neon MCP connector](/agentkit/connectors/neonmcp/) [Connect to Neon MCP. Manage Neon serverless Postgres databases, projects, branches, and queries from your AI workflows.](/agentkit/connectors/neonmcp/) [OAuth 2.1/DCR](/agentkit/connectors/neonmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/netlify.svg)](/agentkit/connectors/netlifymcp/) [Netlify MCP connector](/agentkit/connectors/netlifymcp/) [Build, deploy, and manage Netlify projects — sites, functions, environment variables, forms, blobs, and edge functions — from AI agents via the Netlify...](/agentkit/connectors/netlifymcp/) [OAuth 2.1/DCR](/agentkit/connectors/netlifymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pagerduty.svg)](/agentkit/connectors/pagerduty/) [PagerDuty connector](/agentkit/connectors/pagerduty/) [Connect to PagerDuty to manage incidents, services, users, teams, escalation policies, schedules, and on-call rotations.](/agentkit/connectors/pagerduty/) [OAuth 2.0](/agentkit/connectors/pagerduty/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/parallel-ai.svg)](/agentkit/connectors/parallelaitaskmcp/) [Parallel AI Task MCP connector](/agentkit/connectors/parallelaitaskmcp/) [Connect to Parallel AI Task MCP to run deep research tasks and task groups directly from your AI workflows.](/agentkit/connectors/parallelaitaskmcp/) [Bearer Token](/agentkit/connectors/parallelaitaskmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pixelbin.svg)](/agentkit/connectors/pixelbinmcp/) [Pixelbin MCP connector](/agentkit/connectors/pixelbinmcp/) [Image and video transformation, optimization, and management platform.](/agentkit/connectors/pixelbinmcp/) [OAuth2.1/DCR](/agentkit/connectors/pixelbinmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/planetscale.svg)](/agentkit/connectors/planetscalemcp/) [Planet Scale MCP connector](/agentkit/connectors/planetscalemcp/) [Connect to PlanetScale MCP. Run SQL queries, inspect database branches and schemas, get query performance insights, and manage organizations and invoices...](/agentkit/connectors/planetscalemcp/) [OAuth 2.1/DCR](/agentkit/connectors/planetscalemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/postman.svg)](/agentkit/connectors/postmanmcp/) [Postman MCP connector](/agentkit/connectors/postmanmcp/) [Connect to the Postman MCP server to manage collections, workspaces, environments, and APIs directly from your AI workflows.](/agentkit/connectors/postmanmcp/) [OAuth 2.1/DCR](/agentkit/connectors/postmanmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/postmark.svg)](/agentkit/connectors/postmark/) [Postmark connector](/agentkit/connectors/postmark/) [Send and track transactional and broadcast email with Postmark. Manage templates, message streams, bounces, suppressions, webhooks, and delivery...](/agentkit/connectors/postmark/) [API Key](/agentkit/connectors/postmark/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/prisma.svg)](/agentkit/connectors/prismamcp/) [Prisma MCP connector](/agentkit/connectors/prismamcp/) [Connect to Prisma MCP. Manage Prisma Postgres databases, run SQL queries, handle backups, and manage connection strings from your AI workflows.](/agentkit/connectors/prismamcp/) [OAuth 2.1/DCR](/agentkit/connectors/prismamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/quicknode.svg)](/agentkit/connectors/quicknodemcp/) [Quicknode MCP connector](/agentkit/connectors/quicknodemcp/) [Connect to QuickNode MCP. Create and manage blockchain RPC endpoints, configure security rules, set rate limits, and monitor usage and logs from your AI...](/agentkit/connectors/quicknodemcp/) [OAuth 2.1/DCR](/agentkit/connectors/quicknodemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/replit.svg)](/agentkit/connectors/replitmcp/) [Replit MCP connector](/agentkit/connectors/replitmcp/) [Connect to Replit MCP. Create, update, and inspect Replit apps from natural-language prompts, list your apps, and resolve apps by name from your AI...](/agentkit/connectors/replitmcp/) [OAuth 2.1/DCR](/agentkit/connectors/replitmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/resend.svg)](/agentkit/connectors/resend/) [Resend connector](/agentkit/connectors/resend/) [Resend is an email API platform for developers. Send transactional and marketing emails, manage sending domains, contacts, audiences, broadcasts...](/agentkit/connectors/resend/) [Bearer Token](/agentkit/connectors/resend/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sanity.svg)](/agentkit/connectors/sanitymcp/) [Sanity MCP connector](/agentkit/connectors/sanitymcp/) [Connect to Sanity. Manage structured content, documents, datasets, schemas, releases, and media assets for headless CMS workflows.](/agentkit/connectors/sanitymcp/) [OAuth 2.1/DCR](/agentkit/connectors/sanitymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/scrapfly.svg)](/agentkit/connectors/scarpflymcp/) [Scarpfly MCP connector](/agentkit/connectors/scarpflymcp/) [Connect to Scrapfly MCP. Scrape web pages, take screenshots, and control a cloud browser with anti-bot bypass, JS rendering, and proxy support.](/agentkit/connectors/scarpflymcp/) [OAuth 2.1/DCR](/agentkit/connectors/scarpflymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/semaphoreci.svg)](/agentkit/connectors/semaphorecimcp/) [Semaphore CI MCP connector](/agentkit/connectors/semaphorecimcp/) [Semaphore CI is a fast, cloud-native continuous integration and delivery platform that automates building, testing, and deploying software with flexible...](/agentkit/connectors/semaphorecimcp/) [OAuth2.1/DCR](/agentkit/connectors/semaphorecimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sendgrid.svg)](/agentkit/connectors/sendgrid/) [SendGrid connector](/agentkit/connectors/sendgrid/) [Connect to Twilio SendGrid to send transactional and marketing email at scale, manage templates, contacts, lists, segments, and single sends, verify...](/agentkit/connectors/sendgrid/) [Bearer Token](/agentkit/connectors/sendgrid/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sentry.svg)](/agentkit/connectors/sentrymcp/) [Sentry MCP connector](/agentkit/connectors/sentrymcp/) [Connect to Sentry MCP server to monitor errors, investigate issues, manage projects, and analyze performance directly from your AI workflows.](/agentkit/connectors/sentrymcp/) [OAuth 2.1/DCR](/agentkit/connectors/sentrymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sportradar.svg)](/agentkit/connectors/sportradarmcp/) [Sportradar MCP connector](/agentkit/connectors/sportradarmcp/) [Connect to Sportradar MCP. Browse and search sports data API specs, discover endpoints, check coverage, and access guide pages from your AI workflows.](/agentkit/connectors/sportradarmcp/) [OAuth 2.1/DCR](/agentkit/connectors/sportradarmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/stackai.svg)](/agentkit/connectors/stackaimcp/) [Stack.ai MCP connector](/agentkit/connectors/stackaimcp/) [Connect to Stack AI MCP. Build, run, and manage AI workflow projects, search knowledge bases, list integration providers, and inspect execution traces...](/agentkit/connectors/stackaimcp/) [OAuth 2.1/DCR](/agentkit/connectors/stackaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/stripe.svg)](/agentkit/connectors/stripe/) [Stripe connector](/agentkit/connectors/stripe/) [Connect to Stripe to manage customers, payments, products, subscriptions, invoices, and financial data.](/agentkit/connectors/stripe/) [Bearer Token](/agentkit/connectors/stripe/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/supabase.svg)](/agentkit/connectors/supabase/) [Supabase connector](/agentkit/connectors/supabase/) [Connect to the Supabase Management API to manage organizations, projects, database branches, API keys, secrets, custom domains, network restrictions...](/agentkit/connectors/supabase/) [OAuth 2.0](/agentkit/connectors/supabase/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/swagger.svg)](/agentkit/connectors/swaggermcp/) [Swagger MCP connector](/agentkit/connectors/swaggermcp/) [Connect to Swagger MCP. Create and manage APIs, developer portals, and documentation in SwaggerHub from AI workflows.](/agentkit/connectors/swaggermcp/) [OAuth 2.1/DCR](/agentkit/connectors/swaggermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tavily.svg)](/agentkit/connectors/tavilymcp/) [Tavily MCP connector](/agentkit/connectors/tavilymcp/) [Connect to Tavily MCP. Search the web, crawl websites, extract content, map site structure, and run deep research using Tavily's AI-powered search API.](/agentkit/connectors/tavilymcp/) [OAuth 2.1/DCR](/agentkit/connectors/tavilymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/testdino.svg)](/agentkit/connectors/testidinomcp/) [Testdino MCP connector](/agentkit/connectors/testidinomcp/) [TestDino is a Playwright test reporting and analytics platform that centralizes test data, detects flaky tests, and provides AI-powered debugging via MCP...](/agentkit/connectors/testidinomcp/) [OAuth2.1/DCR](/agentkit/connectors/testidinomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tinyfish.svg)](/agentkit/connectors/tinyfishmcp/) [Tinyfish MCP connector](/agentkit/connectors/tinyfishmcp/) [Connect to Tinyfish MCP. Run browser-based web automations, fetch page content, and search the web using a real cloud Chrome browser.](/agentkit/connectors/tinyfishmcp/) [OAuth 2.1/DCR](/agentkit/connectors/tinyfishmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/v0.svg)](/agentkit/connectors/v0mcp/) [v0 MCP connector](/agentkit/connectors/v0mcp/) [Connect to v0 by Vercel to generate and iterate on web app UIs from natural language. Create chats, send follow-up messages, and inspect v0 Platform chats...](/agentkit/connectors/v0mcp/) [Bearer Token](/agentkit/connectors/v0mcp/) [![](https://raw.githubusercontent.com/simple-icons/simple-icons/develop/icons/vercel.svg)](/agentkit/connectors/vercel/) [Vercel connector](/agentkit/connectors/vercel/) [Connect to Vercel. Access user profile, teams, projects, deployments, and environment settings.](/agentkit/connectors/vercel/) [OAuth 2.0](/agentkit/connectors/vercel/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/vercel.svg)](/agentkit/connectors/vercelmcp/) [Vercel MCP connector](/agentkit/connectors/vercelmcp/) [Connect to Vercel MCP to manage deployments, projects, domains, environment variables, and team resources directly from your AI workflows.](/agentkit/connectors/vercelmcp/) [OAuth 2.1](/agentkit/connectors/vercelmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/webflow.svg)](/agentkit/connectors/webflowmcp/) [Webflow MCP connector](/agentkit/connectors/webflowmcp/) [Connect to Webflow. Build and manage websites, pages, components, styles, assets, CMS collections, and site settings through the Webflow Designer and Data...](/agentkit/connectors/webflowmcp/) [OAuth 2.1/DCR](/agentkit/connectors/webflowmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/whop.svg)](/agentkit/connectors/whopmcp/) [Whop MCP connector](/agentkit/connectors/whopmcp/) [Whop is a platform for selling digital products, memberships, and communities.](/agentkit/connectors/whopmcp/) [OAuth2.1/DCR](/agentkit/connectors/whopmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/wix.svg)](/agentkit/connectors/wixmcp/) [Wix MCP connector](/agentkit/connectors/wixmcp/) [Connect to Wix MCP. Build and manage Wix sites, call REST APIs, search documentation, upload media, and suggest domains from your AI workflows.](/agentkit/connectors/wixmcp/) [OAuth 2.1/DCR](/agentkit/connectors/wixmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zapier.svg)](/agentkit/connectors/zapiermcp/) [Zapier MCP connector](/agentkit/connectors/zapiermcp/) [Connect to Zapier MCP to automate workflows and integrate with thousands of apps directly from your AI agent.](/agentkit/connectors/zapiermcp/) [OAuth 2.1/DCR](/agentkit/connectors/zapiermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zenrows.svg)](/agentkit/connectors/zenrowsmcp/) [ZenRows MCP connector](/agentkit/connectors/zenrowsmcp/) [Connect to ZenRows MCP. Scrape any webpage with anti-bot bypass, render JavaScript-heavy sites, and automate browsers through ZenRows' cloud...](/agentkit/connectors/zenrowsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/zenrowsmcp/) ## Files & Documents [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/affinda.svg)](/agentkit/connectors/affindamcp/) [Affinda MCP connector](/agentkit/connectors/affindamcp/) [AI-powered document processing platform that extracts, validates, and integrates structured data from invoices, resumes, contracts, and custom document...](/agentkit/connectors/affindamcp/) [OAuth2.1/DCR](/agentkit/connectors/affindamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airparser.svg)](/agentkit/connectors/airparsermcp/) [Airparser MCP connector](/agentkit/connectors/airparsermcp/) [AI-powered document parser that extracts structured data from PDFs, emails, and other documents.](/agentkit/connectors/airparsermcp/) [OAuth2.1/DCR](/agentkit/connectors/airparsermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/box.svg)](/agentkit/connectors/box/) [Box connector](/agentkit/connectors/box/) [Box is a cloud content management platform. Manage files, folders, users, groups, collaborations, tasks, comments, webhooks, search, and more using the...](/agentkit/connectors/box/) [OAuth 2.0](/agentkit/connectors/box/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/box.svg)](/agentkit/connectors/boxmcp/) [Box MCP connector](/agentkit/connectors/boxmcp/) [Connect to Box via MCP to manage files, folders, collaborations, users, groups, tasks, comments, and search content directly from your AI workflows.](/agentkit/connectors/boxmcp/) [OAuth 2.1](/agentkit/connectors/boxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/carbone.svg)](/agentkit/connectors/carboneiomcp/) [Carbone.io MCP connector](/agentkit/connectors/carboneiomcp/) [Connect to Carbone.io MCP. Upload templates, render documents by merging templates with JSON data, convert between 100+ formats, and manage template...](/agentkit/connectors/carboneiomcp/) [Bearer Token](/agentkit/connectors/carboneiomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/confluence.svg)](/agentkit/connectors/confluence/) [Confluence connector](/agentkit/connectors/confluence/) [Connect to Confluence. Manage spaces, pages, content, and team collaboration](/agentkit/connectors/confluence/) [OAuth 2.0](/agentkit/connectors/confluence/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/contentful.svg)](/agentkit/connectors/contentfulmcp/) [Contentful MCP connector](/agentkit/connectors/contentfulmcp/) [Connect to Contentful MCP. Manage spaces, entries, assets, content types, and taxonomies in your Contentful CMS from AI workflows.](/agentkit/connectors/contentfulmcp/) [OAuth 2.1/DCR](/agentkit/connectors/contentfulmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/conversiontools.svg)](/agentkit/connectors/conversiontoolsmcp/) [Conversion Tools MCP connector](/agentkit/connectors/conversiontoolsmcp/) [Connect to Conversion Tools MCP. Convert files between 140+ formats including documents, images, audio, video, and data files from your AI workflows.](/agentkit/connectors/conversiontoolsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/conversiontoolsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/convertapi.svg)](/agentkit/connectors/convertapimcp/) [ConvertAPI MCP connector](/agentkit/connectors/convertapimcp/) [Connect to ConvertAPI MCP. Convert, merge, split, and transform files across 200+ formats including PDF, Word, Excel, images, and more.](/agentkit/connectors/convertapimcp/) [OAuth 2.1/DCR](/agentkit/connectors/convertapimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/docsautomator.svg)](/agentkit/connectors/docsautomatormcp/) [Docsautomator MCP connector](/agentkit/connectors/docsautomatormcp/) [Connect to DocsAutomator MCP. Generate documents and PDFs from templates using your data, automating document creation workflows.](/agentkit/connectors/docsautomatormcp/) [OAuth 2.1/DCR](/agentkit/connectors/docsautomatormcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/drop_box.svg)](/agentkit/connectors/dropbox/) [Dropbox connector](/agentkit/connectors/dropbox/) [Connect to Dropbox. Manage files, folders, sharing, and cloud storage workflows](/agentkit/connectors/dropbox/) [OAuth 2.0](/agentkit/connectors/dropbox/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/drop_box.svg)](/agentkit/connectors/dropboxmcp/) [Dropbox MCP connector](/agentkit/connectors/dropboxmcp/) [Connect to Dropbox. Manage files and folders, create shared links, search content, and handle file requests from your AI workflows.](/agentkit/connectors/dropboxmcp/) [OAuth 2.1](/agentkit/connectors/dropboxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_docs.svg)](/agentkit/connectors/googledocs/) [Google Docs connector](/agentkit/connectors/googledocs/) [Connect to Google Docs. Create, edit, and collaborate on documents](/agentkit/connectors/googledocs/) [OAuth 2.0](/agentkit/connectors/googledocs/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_drive.svg)](/agentkit/connectors/googledrive/) [Google Drive connector](/agentkit/connectors/googledrive/) [Connect to Google Drive. Manage files, folders, and sharing permissions](/agentkit/connectors/googledrive/) [OAuth 2.0](/agentkit/connectors/googledrive/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_forms.svg)](/agentkit/connectors/googleforms/) [Google Forms connector](/agentkit/connectors/googleforms/) [Connect to Google Forms. Create, view, and manage forms and responses securely](/agentkit/connectors/googleforms/) [OAuth 2.0](/agentkit/connectors/googleforms/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_sheets.svg)](/agentkit/connectors/googlesheets/) [Google Sheets connector](/agentkit/connectors/googlesheets/) [Connect to Google Sheets. Create, edit, and analyze spreadsheets with powerful data management capabilities](/agentkit/connectors/googlesheets/) [OAuth 2.0](/agentkit/connectors/googlesheets/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_slides.svg)](/agentkit/connectors/googleslides/) [Google Slides connector](/agentkit/connectors/googleslides/) [Connect to Google Slides to create, read, and modify presentations programmatically.](/agentkit/connectors/googleslides/) [OAuth 2.0](/agentkit/connectors/googleslides/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/microsoft365.svg)](/agentkit/connectors/microsoft365/) [Microsoft 365 connector](/agentkit/connectors/microsoft365/) [Connect to Microsoft 365. Unified access to Outlook, Excel, Word, OneNote, OneDrive, SharePoint, and Teams through Microsoft Graph API.](/agentkit/connectors/microsoft365/) [OAuth 2.0](/agentkit/connectors/microsoft365/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/excel.svg)](/agentkit/connectors/microsoftexcel/) [Microsoft Excel connector](/agentkit/connectors/microsoftexcel/) [Connect to Microsoft Excel. Access, read, and modify spreadsheets stored in OneDrive or SharePoint through Microsoft Graph API.](/agentkit/connectors/microsoftexcel/) [OAuth 2.0](/agentkit/connectors/microsoftexcel/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/word.svg)](/agentkit/connectors/microsoftword/) [Microsoft Word connector](/agentkit/connectors/microsoftword/) [Connect to Microsoft Word. Authenticate with your Microsoft account to create, read, and edit Word documents stored in OneDrive or SharePoint through...](/agentkit/connectors/microsoftword/) [OAuth 2.0](/agentkit/connectors/microsoftword/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/notion.svg)](/agentkit/connectors/notion/) [Notion connector](/agentkit/connectors/notion/) [Connect to Notion workspace. Create, edit pages, manage databases, and collaborate on content](/agentkit/connectors/notion/) [OAuth 2.0](/agentkit/connectors/notion/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/onedrive.svg)](/agentkit/connectors/onedrive/) [OneDrive connector](/agentkit/connectors/onedrive/) [Connect to OneDrive. Manage files, folders, and cloud storage with Microsoft OneDrive](/agentkit/connectors/onedrive/) [OAuth 2.0](/agentkit/connectors/onedrive/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/onenote.svg)](/agentkit/connectors/onenote/) [OneNote connector](/agentkit/connectors/onenote/) [Connect to Microsoft OneNote. Access, create, and manage notebooks, sections, and pages stored in OneDrive or SharePoint through Microsoft Graph API.](/agentkit/connectors/onenote/) [OAuth 2.0](/agentkit/connectors/onenote/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pandadoc.svg)](/agentkit/connectors/pandadocmcp/) [Pandadoc MCP connector](/agentkit/connectors/pandadocmcp/) [Connect to PandaDoc MCP. Create, send, and manage documents, templates, and e-signatures directly from your AI workflows.](/agentkit/connectors/pandadocmcp/) [OAuth 2.1/DCR](/agentkit/connectors/pandadocmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sanity.svg)](/agentkit/connectors/sanitymcp/) [Sanity MCP connector](/agentkit/connectors/sanitymcp/) [Connect to Sanity. Manage structured content, documents, datasets, schemas, releases, and media assets for headless CMS workflows.](/agentkit/connectors/sanitymcp/) [OAuth 2.1/DCR](/agentkit/connectors/sanitymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/send.svg)](/agentkit/connectors/sendmcp/) [Send MCP connector](/agentkit/connectors/sendmcp/) [Connect to Send to create, edit, and share Claude-generated documents as polished web pages with engagement tracking, custom domains, and team asset...](/agentkit/connectors/sendmcp/) [OAuth2.1/DCR](/agentkit/connectors/sendmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sharepoint.svg)](/agentkit/connectors/sharepoint/) [SharePoint connector](/agentkit/connectors/sharepoint/) [Connect to SharePoint. Manage sites, documents, lists, and collaborative content](/agentkit/connectors/sharepoint/) [OAuth 2.0](/agentkit/connectors/sharepoint/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/signwell.svg)](/agentkit/connectors/signwell/) [SignWell connector](/agentkit/connectors/signwell/) [SignWell is an e-signature platform for sending, signing, and managing documents. Connect to create and send documents for signature, manage templates...](/agentkit/connectors/signwell/) [API Key](/agentkit/connectors/signwell/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/slite.svg)](/agentkit/connectors/slitemcp/) [Slite MCP connector](/agentkit/connectors/slitemcp/) [Connect to Slite MCP. Create and manage notes, channels, collections, and comments in Slite from AI workflows.](/agentkit/connectors/slitemcp/) [OAuth 2.1/DCR](/agentkit/connectors/slitemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/synapse.svg)](/agentkit/connectors/synapsemcp/) [Synapse MCP connector](/agentkit/connectors/synapsemcp/) [Connect to the Synapse MCP server (Sage Bionetworks) to explore Synapse entities, annotations, provenance, and project structure, and to search...](/agentkit/connectors/synapsemcp/) [OAuth 2.1/DCR](/agentkit/connectors/synapsemcp/) ## Finance [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/coinmarketcap.svg)](/agentkit/connectors/coinmarketcapmcp/) [CoinMarketCap MCP connector](/agentkit/connectors/coinmarketcapmcp/) [Connect to CoinMarketCap MCP. Access real-time crypto quotes, market metrics, technical analysis, trending narratives, and news from your AI workflows.](/agentkit/connectors/coinmarketcapmcp/) [OAuth 2.1/DCR](/agentkit/connectors/coinmarketcapmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mtnewswires.svg)](/agentkit/connectors/mtnewswiresmcp/) [MT Newswires MCP connector](/agentkit/connectors/mtnewswiresmcp/) [Connect to the MT Newswires MCP server on viaNexus to search and retrieve real-time, low-latency financial news across equities, fixed income...](/agentkit/connectors/mtnewswiresmcp/) [OAuth 2.1/DCR](/agentkit/connectors/mtnewswiresmcp/) ## Healthcare [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/customsmartfhir.png)](/agentkit/connectors/customsmartfhir/) [SMART App on FHIR connector](/agentkit/connectors/customsmartfhir/) [SMART App on FHIR is a healthcare interoperability provider that enables secure access to electronic health records and clinical data using the SMART on...](/agentkit/connectors/customsmartfhir/) [SMART On FHIR](/agentkit/connectors/customsmartfhir/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/advancedmd.png)](/agentkit/connectors/advancedmd/) [AdvancedMD connector](/agentkit/connectors/advancedmd/) [AdvancedMD is a cloud-based medical practice management and electronic health record (EHR) platform. This connector uses the SMART on FHIR authorization...](/agentkit/connectors/advancedmd/) [SMART On FHIR](/agentkit/connectors/advancedmd/) ## Marketing [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/adobe.svg)](/agentkit/connectors/adobemarketingagentmcp/) [Adobe Marketing Agent MCP connector](/agentkit/connectors/adobemarketingagentmcp/) [Connect to Adobe Marketing Cloud. Manage campaigns, analytics, and journeys using a natural-language AI assistant.](/agentkit/connectors/adobemarketingagentmcp/) [OAuth 2.1/DCR](/agentkit/connectors/adobemarketingagentmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/adzviser.svg)](/agentkit/connectors/adzvisermcp/) [Adzviser MCP connector](/agentkit/connectors/adzvisermcp/) [Connect to Adzviser MCP to query real-time marketing analytics across 46+ platforms - Google Ads, Facebook Ads, GA4, TikTok, LinkedIn, and more - from a...](/agentkit/connectors/adzvisermcp/) [OAuth 2.1/DCR](/agentkit/connectors/adzvisermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/agencyanalytics.svg)](/agentkit/connectors/agencyanalyticsmcp/) [Agency Analytics MCP connector](/agentkit/connectors/agencyanalyticsmcp/) [Agency Analytics is a marketing reporting platform that enables digital agencies to monitor SEO, PPC, social media, and other channel performance in...](/agentkit/connectors/agencyanalyticsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/agencyanalyticsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/ahrefs.svg)](/agentkit/connectors/ahrefsmcp/) [Ahrefs MCP connector](/agentkit/connectors/ahrefsmcp/) [Connect to Ahrefs MCP to access SEO data including backlinks, keyword research, site audits, rank tracking, and web analytics directly from your AI...](/agentkit/connectors/ahrefsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/ahrefsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airops.svg)](/agentkit/connectors/airopsmcp/) [Airops MCP connector](/agentkit/connectors/airopsmcp/) [Connect to AirOps MCP. Manage brand kits, run AI-powered analytics, track AEO citations, and automate content workflows from your AI agents.](/agentkit/connectors/airopsmcp/) [API Key](/agentkit/connectors/airopsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/apollo.svg)](/agentkit/connectors/apollomcp/) [Apollo MCP connector](/agentkit/connectors/apollomcp/) [Connect to Apollo MCP to search B2B contacts, enrich people and organizations, manage CRM records, and enroll prospects in sequences.](/agentkit/connectors/apollomcp/) [OAuth 2.1/DCR](/agentkit/connectors/apollomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bitly.svg)](/agentkit/connectors/bitlymcp/) [Bitly MCP connector](/agentkit/connectors/bitlymcp/) [Connect with Bitly MCP for URL shortening, link analytics, and branded links.](/agentkit/connectors/bitlymcp/) [OAuth 2.1/DCR](/agentkit/connectors/bitlymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/brevo.svg)](/agentkit/connectors/brevomcp/) [Brevo MCP connector](/agentkit/connectors/brevomcp/) [Connect to Brevo MCP. Manage email and SMS campaigns, transactional emails, contacts, lists, automations, and loyalty programs from your AI workflows.](/agentkit/connectors/brevomcp/) [OAuth 2.1/DCR](/agentkit/connectors/brevomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clay.svg)](/agentkit/connectors/claymcp/) [Clay MCP connector](/agentkit/connectors/claymcp/) [Clay is a go-to-market (GTM) platform that unifies data sourcing from 150+ providers, AI-powered research agents, and workflow orchestration for sales and...](/agentkit/connectors/claymcp/) [OAuth 2.1/DCR](/agentkit/connectors/claymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/commonroom.svg)](/agentkit/connectors/commonroommcp/) [Commonroom MCP connector](/agentkit/connectors/commonroommcp/) [Connect to Common Room MCP to manage community members, objects, and feedback data directly from your AI workflows.](/agentkit/connectors/commonroommcp/) [OAuth 2.1/DCR](/agentkit/connectors/commonroommcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/customerio.svg)](/agentkit/connectors/customeriomcp/) [Customer.io MCP connector](/agentkit/connectors/customeriomcp/) [Connect to Customer.io MCP to manage customers, campaigns, and events](/agentkit/connectors/customeriomcp/) [OAuth 2.1/DCR](/agentkit/connectors/customeriomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dataforseo.svg)](/agentkit/connectors/dataforseomcp/) [Dataforseo MCP connector](/agentkit/connectors/dataforseomcp/) [Connect to DataForSEO. Access real-time SEO data including SERP results, keyword analytics, backlinks analysis, domain technologies, and AI visibility...](/agentkit/connectors/dataforseomcp/) [OAuth 2.1/DCR](/agentkit/connectors/dataforseomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dropcontact.svg)](/agentkit/connectors/dropcontactmcp/) [Dropcontact MCP connector](/agentkit/connectors/dropcontactmcp/) [B2B contact enrichment and email verification platform that finds, verifies, and enriches professional email addresses and company data.](/agentkit/connectors/dropcontactmcp/) [OAuth 2.1/DCR](/agentkit/connectors/dropcontactmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/eden.svg)](/agentkit/connectors/edenmcp/) [Eden MCP connector](/agentkit/connectors/edenmcp/) [Eden is an AI-powered content creation platform that discovers viral trends across 3M+ social media posts and helps creators generate content in their...](/agentkit/connectors/edenmcp/) [OAuth2.1/DCR](/agentkit/connectors/edenmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fullenrich.svg)](/agentkit/connectors/fullenrichmcp/) [Fullenrich MCP connector](/agentkit/connectors/fullenrichmcp/) [Connect to FullEnrich MCP. Enrich contacts with verified email addresses and phone numbers using waterfall enrichment across multiple data providers.](/agentkit/connectors/fullenrichmcp/) [OAuth 2.1/DCR](/agentkit/connectors/fullenrichmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google_ads.png)](/agentkit/connectors/google_ads/) [Google Ads connector](/agentkit/connectors/google_ads/) [Connect to Google Ads to manage advertising campaigns, analyze performance metrics, and optimize ad spending across Google's advertising platform](/agentkit/connectors/google_ads/) [OAuth 2.0](/agentkit/connectors/google_ads/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google.svg)](/agentkit/connectors/googlebusinessprofile/) [Google Business Profile connector](/agentkit/connectors/googlebusinessprofile/) [Google Business Profile lets businesses manage their presence across Google Search and Maps — business information, locations, performance/insights...](/agentkit/connectors/googlebusinessprofile/) [OAuth 2.0](/agentkit/connectors/googlebusinessprofile/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/harvestapi.svg)](/agentkit/connectors/harvestapi/) [HarvestAPI connector](/agentkit/connectors/harvestapi/) [Connect to HarvestAPI to scrape LinkedIn profiles, companies, and job listings, and search for people and jobs using LinkedIn data. Enables AI agents to...](/agentkit/connectors/harvestapi/) [API Key](/agentkit/connectors/harvestapi/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/hub_spot.svg)](/agentkit/connectors/hubspotmcp/) [HubSpot MCP connector](/agentkit/connectors/hubspotmcp/) [Connect to HubSpot MCP. Manage CRM contacts, companies, deals, landing pages, campaigns, and analytics from your AI workflows.](/agentkit/connectors/hubspotmcp/) [OAuth 2.1](/agentkit/connectors/hubspotmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/kit.svg)](/agentkit/connectors/kitmcp/) [Kit MCP connector](/agentkit/connectors/kitmcp/) [Connect to Kit MCP. Manage email subscribers, sequences, broadcasts, tags, and forms for your email marketing workflows.](/agentkit/connectors/kitmcp/) [OAuth 2.1/DCR](/agentkit/connectors/kitmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/klaviyo.svg)](/agentkit/connectors/klaviyomcp/) [Klaviyo MCP connector](/agentkit/connectors/klaviyomcp/) [Connect to Klaviyo MCP. Report, strategize & create with real-time Klaviyo data](/agentkit/connectors/klaviyomcp/) [OAuth 2.1/DCR](/agentkit/connectors/klaviyomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/leadboxer.svg)](/agentkit/connectors/leadboxermcp/) [LeadBoxer MCP connector](/agentkit/connectors/leadboxermcp/) [Connect to LeadBoxer MCP to identify anonymous website visitors and enrich them with firmographic data. LeadBoxer is a B2B lead generation and website...](/agentkit/connectors/leadboxermcp/) [OAuth 2.1/DCR](/agentkit/connectors/leadboxermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/leadfeeder.svg)](/agentkit/connectors/leadfeedermcp/) [Leadfeeder MCP connector](/agentkit/connectors/leadfeedermcp/) [Connect to Leadfeeder's MCP server to identify website visitors, track B2B leads, and surface company-level intent data directly from your AI workflows.](/agentkit/connectors/leadfeedermcp/) [OAuth2.1/DCR](/agentkit/connectors/leadfeedermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lemlist.svg)](/agentkit/connectors/lemlistmcp/) [Lemlist MCP connector](/agentkit/connectors/lemlistmcp/) [Connect to Lemlist MCP. Manage outbound sales campaigns, leads, email sequences, and LinkedIn outreach from your AI workflows.](/agentkit/connectors/lemlistmcp/) [OAuth 2.1/DCR](/agentkit/connectors/lemlistmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/linkedin.svg)](/agentkit/connectors/linkedin/) [LinkedIn connector](/agentkit/connectors/linkedin/) [Connect to LinkedIn to manage posts, ads, organizations, analytics, and professional profiles from your AI workflows.](/agentkit/connectors/linkedin/) [OAuth 2.0](/agentkit/connectors/linkedin/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/linkly.png)](/agentkit/connectors/linklymcp/) [LinklyHQ MCP connector](/agentkit/connectors/linklymcp/) [LinklyHQ is a URL shortening and link management platform offering click analytics, custom domains, UTM tracking, QR codes, and webhook integrations for...](/agentkit/connectors/linklymcp/) [OAuth 2.1/PKCE](/agentkit/connectors/linklymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lusha.svg)](/agentkit/connectors/lushamcp/) [Lusha MCP connector](/agentkit/connectors/lushamcp/) [Connect to Lusha MCP. Search and enrich B2B contacts and companies, find lookalikes, run prospecting searches, and access intent and activity signals from...](/agentkit/connectors/lushamcp/) [API Key](/agentkit/connectors/lushamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mailchimp.svg)](/agentkit/connectors/mailchimp/) [Mailchimp connector](/agentkit/connectors/mailchimp/) [Connect to Mailchimp to manage audiences, campaigns, templates, automations, and reports.](/agentkit/connectors/mailchimp/) [OAuth 2.0](/agentkit/connectors/mailchimp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mailercloud.svg)](/agentkit/connectors/mailercloudmcp/) [Mailercloud MCP connector](/agentkit/connectors/mailercloudmcp/) [Connect to Mailer Cloud MCP. Manage email campaigns, subscriber lists, and automation workflows for your email marketing operations.](/agentkit/connectors/mailercloudmcp/) [OAuth 2.1/DCR](/agentkit/connectors/mailercloudmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mailerlite.svg)](/agentkit/connectors/mailerlitemcp/) [Mailerlite MCP connector](/agentkit/connectors/mailerlitemcp/) [Connect to MailerLite MCP. Manage email campaigns, subscribers, groups, automations, and forms from your AI workflows.](/agentkit/connectors/mailerlitemcp/) [OAuth 2.1/DCR](/agentkit/connectors/mailerlitemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mailgun.svg)](/agentkit/connectors/mailgun/) [Mailgun connector](/agentkit/connectors/mailgun/) [Connect to Mailgun to send transactional and marketing email, manage domains and DNS/DKIM security, mailing lists, suppressions (bounces, complaints...](/agentkit/connectors/mailgun/) [API Key](/agentkit/connectors/mailgun/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/metricool.svg)](/agentkit/connectors/metricoolmcp/) [Metricool MCP connector](/agentkit/connectors/metricoolmcp/) [Metricool is a social media analytics and scheduling platform for managing, analyzing, and scheduling content across Instagram, Twitter/X, Facebook...](/agentkit/connectors/metricoolmcp/) [OAuth2.1/DCR](/agentkit/connectors/metricoolmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/minicoursegenerator.svg)](/agentkit/connectors/minicoursegeneratormcp/) [Mini Course Generator MCP connector](/agentkit/connectors/minicoursegeneratormcp/) [Mini Course Generator is a platform for creating and publishing short, focused online mini-courses. It enables creators to build bite-sized educational...](/agentkit/connectors/minicoursegeneratormcp/) [OAuth2.1/DCR](/agentkit/connectors/minicoursegeneratormcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mixmax.svg)](/agentkit/connectors/mixmaxmcp/) [Mixmax MCP connector](/agentkit/connectors/mixmaxmcp/) [Connect to Mixmax MCP. Manage email sequences, templates, contacts, and engagement analytics from your AI workflows.](/agentkit/connectors/mixmaxmcp/) [OAuth 2.1/DCR](/agentkit/connectors/mixmaxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/profound.svg)](/agentkit/connectors/profoundmcp/) [Profound MCP connector](/agentkit/connectors/profoundmcp/) [Profound is an AI search visibility and marketing analytics platform that helps brands understand and optimize their presence across AI-powered answer...](/agentkit/connectors/profoundmcp/) [OAuth 2.1/DCR](/agentkit/connectors/profoundmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/resend.svg)](/agentkit/connectors/resend/) [Resend connector](/agentkit/connectors/resend/) [Resend is an email API platform for developers. Send transactional and marketing emails, manage sending domains, contacts, audiences, broadcasts...](/agentkit/connectors/resend/) [Bearer Token](/agentkit/connectors/resend/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sendgrid.svg)](/agentkit/connectors/sendgrid/) [SendGrid connector](/agentkit/connectors/sendgrid/) [Connect to Twilio SendGrid to send transactional and marketing email at scale, manage templates, contacts, lists, segments, and single sends, verify...](/agentkit/connectors/sendgrid/) [Bearer Token](/agentkit/connectors/sendgrid/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/storeleads.svg)](/agentkit/connectors/storeleadsmcp/) [StoreLeads MCP connector](/agentkit/connectors/storeleadsmcp/) [Connect to StoreLeads MCP to discover, search, and analyze e-commerce stores and their technology stack from your AI workflows.](/agentkit/connectors/storeleadsmcp/) [Bearer Token](/agentkit/connectors/storeleadsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/supermetrics.svg)](/agentkit/connectors/supermetricsmcp/) [Supermetrics MCP connector](/agentkit/connectors/supermetricsmcp/) [Connect to Supermetrics MCP to query marketing data, discover data sources, manage campaigns, and run analytics across your connected ad and analytics...](/agentkit/connectors/supermetricsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/supermetricsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/surveymonkey.svg)](/agentkit/connectors/surveymonkeymcp/) [SurveyMonkey MCP connector](/agentkit/connectors/surveymonkeymcp/) [Connect to SurveyMonkey to manage surveys, collect responses, and analyze results. Create and update surveys, manage collectors and contacts, and retrieve...](/agentkit/connectors/surveymonkeymcp/) [OAuth2.1/DCR](/agentkit/connectors/surveymonkeymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/X.svg)](/agentkit/connectors/twitter/) [Twitter / X connector](/agentkit/connectors/twitter/) [Connect to Twitter. Read and write Tweets, read users, manage follows, bookmarks, etc.](/agentkit/connectors/twitter/) [Bearer Token](/agentkit/connectors/twitter/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/typeform.svg)](/agentkit/connectors/typeformmcp/) [Typeform MCP connector](/agentkit/connectors/typeformmcp/) [Connect to Typeform MCP to create and manage forms, read responses, and manage workspaces, contacts, and webhooks directly from your AI workflows.](/agentkit/connectors/typeformmcp/) [OAuth 2.1/DCR](/agentkit/connectors/typeformmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/vibeprospecting.svg)](/agentkit/connectors/vibeprospectingmcp/) [Vibe Prospecting MCP connector](/agentkit/connectors/vibeprospectingmcp/) [Connect to Vibe Prospecting by Explorium to build B2B lead lists, research companies and prospects, enrich contacts, and personalize outreach from your AI...](/agentkit/connectors/vibeprospectingmcp/) [OAuth 2.1/DCR](/agentkit/connectors/vibeprospectingmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/youtube.svg)](/agentkit/connectors/youtube/) [YouTube connector](/agentkit/connectors/youtube/) [Connect to YouTube to access channel details, analytics, and upload or manage videos via OAuth 2.0](/agentkit/connectors/youtube/) [OAuth 2.0](/agentkit/connectors/youtube/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zoominfo.svg)](/agentkit/connectors/zoominfo/) [ZoomInfo connector](/agentkit/connectors/zoominfo/) [Connect to ZoomInfo to search and enrich B2B contact and company data, access intent signals, discover technographic insights, and manage GTM Studio...](/agentkit/connectors/zoominfo/) [OAuth 2.0](/agentkit/connectors/zoominfo/) ## Media [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/claap.svg)](/agentkit/connectors/claapmcp/) [Claap MCP connector](/agentkit/connectors/claapmcp/) [Video collaboration platform for recording, sharing, and discussing async video clips — used for meeting recordings, product demos, feedback, and team...](/agentkit/connectors/claapmcp/) [OAuth2.1/DCR](/agentkit/connectors/claapmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/cloudinary.svg)](/agentkit/connectors/cloudinarymcp/) [Cloudinary MCP connector](/agentkit/connectors/cloudinarymcp/) [Connects AI agents to Cloudinary's asset management platform, enabling upload, search, transformation, and organization of media assets through natural...](/agentkit/connectors/cloudinarymcp/) [OAuth2.1/DCR](/agentkit/connectors/cloudinarymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/descript.svg)](/agentkit/connectors/descriptmcp/) [Descript MCP connector](/agentkit/connectors/descriptmcp/) [Connect to Descript MCP. Import media, export transcripts, publish projects, run AI editing agents, and manage jobs from your AI workflows.](/agentkit/connectors/descriptmcp/) [OAuth 2.1/DCR](/agentkit/connectors/descriptmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/diarize.svg)](/agentkit/connectors/diarize/) [Diarize connector](/agentkit/connectors/diarize/) [Connect to Diarize to transcribe and diarize audio and video content from YouTube, X, Instagram, and TikTok. Submit transcription jobs and retrieve...](/agentkit/connectors/diarize/) [Bearer Token](/agentkit/connectors/diarize/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/eden.svg)](/agentkit/connectors/edenmcp/) [Eden MCP connector](/agentkit/connectors/edenmcp/) [Eden is an AI-powered content creation platform that discovers viral trends across 3M+ social media posts and helps creators generate content in their...](/agentkit/connectors/edenmcp/) [OAuth2.1/DCR](/agentkit/connectors/edenmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fever.svg)](/agentkit/connectors/fevermcp/) [Fever MCP connector](/agentkit/connectors/fevermcp/) [Fever is a live entertainment discovery platform. This MCP connector gives AI assistants direct access to Fever's global event catalog — search events by...](/agentkit/connectors/fevermcp/) [OAuth 2.1/DCR](/agentkit/connectors/fevermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/kling.svg)](/agentkit/connectors/klingmcp/) [Kling AI MCP connector](/agentkit/connectors/klingmcp/) [Kling AI is a video and image generation platform. This MCP connector exposes Kling AI capabilities — including video generation and image generation —...](/agentkit/connectors/klingmcp/) [OAuth2.1/DCR](/agentkit/connectors/klingmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/metricool.svg)](/agentkit/connectors/metricoolmcp/) [Metricool MCP connector](/agentkit/connectors/metricoolmcp/) [Metricool is a social media analytics and scheduling platform for managing, analyzing, and scheduling content across Instagram, Twitter/X, Facebook...](/agentkit/connectors/metricoolmcp/) [OAuth2.1/DCR](/agentkit/connectors/metricoolmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mux.svg)](/agentkit/connectors/muxmcp/) [Mux MCP connector](/agentkit/connectors/muxmcp/) [Mux is a video infrastructure platform for developers, providing APIs for video hosting, on-demand streaming, live streaming, and playback with analytics...](/agentkit/connectors/muxmcp/) [OAuth2.1/DCR](/agentkit/connectors/muxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pixelbin.svg)](/agentkit/connectors/pixelbinmcp/) [Pixelbin MCP connector](/agentkit/connectors/pixelbinmcp/) [Image and video transformation, optimization, and management platform.](/agentkit/connectors/pixelbinmcp/) [OAuth2.1/DCR](/agentkit/connectors/pixelbinmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/quizvideo.svg)](/agentkit/connectors/quizvideomcp/) [Quiz.Video MCP connector](/agentkit/connectors/quizvideomcp/) [Quiz.Video is an AI-powered platform for creating short-form quiz and flashcard videos. Transform topics, URLs, or documents into shareable quiz and...](/agentkit/connectors/quizvideomcp/) [OAuth 2.1/DCR](/agentkit/connectors/quizvideomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/runware.svg)](/agentkit/connectors/runwaremcp/) [Runware MCP connector](/agentkit/connectors/runwaremcp/) [Connect to Runware's MCP server to generate and edit images, video, audio, and 3D assets using thousands of AI models through a single API.](/agentkit/connectors/runwaremcp/) [OAuth2.1/DCR](/agentkit/connectors/runwaremcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/splice.svg)](/agentkit/connectors/splicemcp/) [Splice MCP connector](/agentkit/connectors/splicemcp/) [Connect to Splice MCP. Search the Splice sample catalog, create and update multi-track stacks, download audio assets, and generate arrangements from text...](/agentkit/connectors/splicemcp/) [OAuth 2.1/DCR](/agentkit/connectors/splicemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/vimeo.svg)](/agentkit/connectors/vimeo/) [Vimeo connector](/agentkit/connectors/vimeo/) [Connect to Vimeo API v3.4. Upload and manage videos, organize content into showcases and folders, manage channels, handle comments, likes, and webhooks.](/agentkit/connectors/vimeo/) [OAuth 2.0](/agentkit/connectors/vimeo/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/youtube.svg)](/agentkit/connectors/youtube/) [YouTube connector](/agentkit/connectors/youtube/) [Connect to YouTube to access channel details, analytics, and upload or manage videos via OAuth 2.0](/agentkit/connectors/youtube/) [OAuth 2.0](/agentkit/connectors/youtube/) ## Monitoring [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/agencyanalytics.svg)](/agentkit/connectors/agencyanalyticsmcp/) [Agency Analytics MCP connector](/agentkit/connectors/agencyanalyticsmcp/) [Agency Analytics is a marketing reporting platform that enables digital agencies to monitor SEO, PPC, social media, and other channel performance in...](/agentkit/connectors/agencyanalyticsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/agencyanalyticsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/appsignal.svg)](/agentkit/connectors/appsignalmcp/) [AppSignal MCP connector](/agentkit/connectors/appsignalmcp/) [AppSignal is an application monitoring and performance management platform providing error tracking, performance monitoring, and alerting for Ruby...](/agentkit/connectors/appsignalmcp/) [OAuth2.1/DCR](/agentkit/connectors/appsignalmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/axiom.svg)](/agentkit/connectors/axiommcp/) [Axiom MCP connector](/agentkit/connectors/axiommcp/) [Axiom is a cloud-native data analytics and observability platform for ingesting, storing, and querying logs, events, traces, and metrics at scale. The MCP...](/agentkit/connectors/axiommcp/) [OAuth2.1/DCR](/agentkit/connectors/axiommcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/betterstack.svg)](/agentkit/connectors/betterstackmcp/) [Betterstack MCP connector](/agentkit/connectors/betterstackmcp/) [Monitor uptime, manage logs, and respond to incidents with Better Stack's observability platform.](/agentkit/connectors/betterstackmcp/) [OAuth2.1/DCR](/agentkit/connectors/betterstackmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bugsnag.svg)](/agentkit/connectors/bugsnagmcp/) [Bugsnag MCP connector](/agentkit/connectors/bugsnagmcp/) [Connect to Bugsnag MCP. Monitor errors, releases, traces, and span groups across your projects from your AI workflows.](/agentkit/connectors/bugsnagmcp/) [OAuth 2.1/DCR](/agentkit/connectors/bugsnagmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/cloudflare.svg)](/agentkit/connectors/cloudflare/) [Cloudflare connector](/agentkit/connectors/cloudflare/) [Cloudflare is a cloud platform providing DNS management, CDN, security, and networking services. This connector enables automated management of zones, DNS...](/agentkit/connectors/cloudflare/) [OAuth 2.0](/agentkit/connectors/cloudflare/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/databox.svg)](/agentkit/connectors/databoxmcp/) [Databox MCP connector](/agentkit/connectors/databoxmcp/) [Connect to Databox MCP. Query metrics, manage dashboards, and push custom data to your Databox analytics and reporting platform.](/agentkit/connectors/databoxmcp/) [OAuth 2.1/DCR](/agentkit/connectors/databoxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/datadog.svg)](/agentkit/connectors/datadog/) [Datadog connector](/agentkit/connectors/datadog/) [Connect to Datadog to monitor metrics, logs, traces, dashboards, monitors, incidents, SLOs, synthetics, and security signals across your infrastructure.](/agentkit/connectors/datadog/) [API Key](/agentkit/connectors/datadog/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/globalping.svg)](/agentkit/connectors/globalpingmcp/) [Globalping MCP connector](/agentkit/connectors/globalpingmcp/) [Globalping is a global network measurement platform for running ping, traceroute, DNS lookup, HTTP, and MTR tests from hundreds of probe locations...](/agentkit/connectors/globalpingmcp/) [OAuth2.1/DCR](/agentkit/connectors/globalpingmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gtmetrix.svg)](/agentkit/connectors/gtmetrixmcp/) [GTmetrix MCP connector](/agentkit/connectors/gtmetrixmcp/) [Connect to GTmetrix MCP to analyze web page performance, run speed tests, monitor Core Web Vitals, and get actionable optimization recommendations...](/agentkit/connectors/gtmetrixmcp/) [OAuth 2.1/DCR](/agentkit/connectors/gtmetrixmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jam.svg)](/agentkit/connectors/jammcp/) [Jam MCP connector](/agentkit/connectors/jammcp/) [Connect to Jam MCP. Access bug reports, console logs, network requests, user events, and video transcripts from your AI workflows.](/agentkit/connectors/jammcp/) [OAuth 2.1/DCR](/agentkit/connectors/jammcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/launchdarkly.svg)](/agentkit/connectors/launchdarklymcp/) [LaunchDarkly MCP connector](/agentkit/connectors/launchdarklymcp/) [Connect to LaunchDarkly's hosted MCP server to manage feature flags, experiments, and release controls directly from your AI workflows.](/agentkit/connectors/launchdarklymcp/) [OAuth2.1/DCR](/agentkit/connectors/launchdarklymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/logrocket.svg)](/agentkit/connectors/logrocketmcp/) [LogRocket MCP connector](/agentkit/connectors/logrocketmcp/) [Connect to LogRocket to access session data, query analytics, investigate user-reported issues, and detect regressions directly from your AI workflows.](/agentkit/connectors/logrocketmcp/) [OAuth2.1/DCR](/agentkit/connectors/logrocketmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pagerduty.svg)](/agentkit/connectors/pagerduty/) [PagerDuty connector](/agentkit/connectors/pagerduty/) [Connect to PagerDuty to manage incidents, services, users, teams, escalation policies, schedules, and on-call rotations.](/agentkit/connectors/pagerduty/) [OAuth 2.0](/agentkit/connectors/pagerduty/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pendo.svg)](/agentkit/connectors/pendomcp/) [Pendo MCP connector](/agentkit/connectors/pendomcp/) [Connect to Pendo MCP to access product analytics, user guidance, and engagement data directly from your AI workflows.](/agentkit/connectors/pendomcp/) [OAuth 2.1/DCR](/agentkit/connectors/pendomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/quicknode.svg)](/agentkit/connectors/quicknodemcp/) [Quicknode MCP connector](/agentkit/connectors/quicknodemcp/) [Connect to QuickNode MCP. Create and manage blockchain RPC endpoints, configure security rules, set rate limits, and monitor usage and logs from your AI...](/agentkit/connectors/quicknodemcp/) [OAuth 2.1/DCR](/agentkit/connectors/quicknodemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sentry.svg)](/agentkit/connectors/sentrymcp/) [Sentry MCP connector](/agentkit/connectors/sentrymcp/) [Connect to Sentry MCP server to monitor errors, investigate issues, manage projects, and analyze performance directly from your AI workflows.](/agentkit/connectors/sentrymcp/) [OAuth 2.1/DCR](/agentkit/connectors/sentrymcp/) [![](https://dac-static.atlassian.com/_static/Statuspage-blue.svg)](/agentkit/connectors/statuspage/) [Statuspage connector](/agentkit/connectors/statuspage/) [Connect to Statuspage. Manage status pages, incidents, components, component groups, subscribers, metrics, and page access permissions.](/agentkit/connectors/statuspage/) [API Key](/agentkit/connectors/statuspage/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/testdino.svg)](/agentkit/connectors/testidinomcp/) [Testdino MCP connector](/agentkit/connectors/testidinomcp/) [TestDino is a Playwright test reporting and analytics platform that centralizes test data, detects flaky tests, and provides AI-powered debugging via MCP...](/agentkit/connectors/testidinomcp/) [OAuth2.1/DCR](/agentkit/connectors/testidinomcp/) ## Productivity [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/agentmail.svg)](/agentkit/connectors/agentmailmcp/) [Agentmail MCP connector](/agentkit/connectors/agentmailmcp/) [Connect to Agentmail MCP. Manage inboxes, send and receive email, handle drafts, threads, and attachments from your AI workflows.](/agentkit/connectors/agentmailmcp/) [OAuth 2.1/DCR](/agentkit/connectors/agentmailmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airtable.svg)](/agentkit/connectors/airtablemcp/) [Airtable MCP connector](/agentkit/connectors/airtablemcp/) [Connect to Airtable MCP. Manage bases, tables, records, views, fields, and automations from your AI workflows.](/agentkit/connectors/airtablemcp/) [OAuth 2.1/DCR](/agentkit/connectors/airtablemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/anakin.svg)](/agentkit/connectors/anakinmcp/) [Anakin MCP connector](/agentkit/connectors/anakinmcp/) [Anakin is an AI platform and marketplace that lets you build, deploy, and access a wide range of AI tools and automated workflows. This MCP connector...](/agentkit/connectors/anakinmcp/) [OAuth2.1/DCR](/agentkit/connectors/anakinmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/asana-n.svg)](/agentkit/connectors/asana/) [Asana connector](/agentkit/connectors/asana/) [Connect to Asana. Manage tasks, projects, teams, and workflow automation](/agentkit/connectors/asana/) [OAuth 2.0](/agentkit/connectors/asana/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/asana-n.svg)](/agentkit/connectors/asanamcp/) [Asana MCP connector](/agentkit/connectors/asanamcp/) [Connect to Asana MCP server to manage tasks, projects, and teams directly from your AI workflows.](/agentkit/connectors/asanamcp/) [OAuth 2.1](/agentkit/connectors/asanamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/atlassian.svg)](/agentkit/connectors/atlassianmcp/) [Atlassian Rovo MCP connector](/agentkit/connectors/atlassianmcp/) [Connect to Atlassian Rovo MCP server to manage Jira issues, Confluence pages, and Compass components directly from your AI workflows.](/agentkit/connectors/atlassianmcp/) [OAuth 2.1/DCR](/agentkit/connectors/atlassianmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/attio.svg)](/agentkit/connectors/attiomcp/) [Attio MCP connector](/agentkit/connectors/attiomcp/) [Connect to Attio MCP. Access and manage CRM records, lists, notes, tasks, emails, and workspace data across people, companies, and deals.](/agentkit/connectors/attiomcp/) [OAuth 2.1/DCR](/agentkit/connectors/attiomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bonsai.svg)](/agentkit/connectors/bonsaimcp/) [Bonsai MCP connector](/agentkit/connectors/bonsaimcp/) [Connect to Bonsai, the all-in-one business management platform for freelancers and agencies. Manage projects, tasks, CRM contacts, deals, invoices, and...](/agentkit/connectors/bonsaimcp/) [OAuth2.1/DCR](/agentkit/connectors/bonsaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/box.svg)](/agentkit/connectors/box/) [Box connector](/agentkit/connectors/box/) [Box is a cloud content management platform. Manage files, folders, users, groups, collaborations, tasks, comments, webhooks, search, and more using the...](/agentkit/connectors/box/) [OAuth 2.0](/agentkit/connectors/box/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/box.svg)](/agentkit/connectors/boxmcp/) [Box MCP connector](/agentkit/connectors/boxmcp/) [Connect to Box via MCP to manage files, folders, collaborations, users, groups, tasks, comments, and search content directly from your AI workflows.](/agentkit/connectors/boxmcp/) [OAuth 2.1](/agentkit/connectors/boxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/cal.svg)](/agentkit/connectors/calmcp/) [Cal MCP connector](/agentkit/connectors/calmcp/) [Connect to Cal MCP. Manage bookings, event types, schedules, and availability from your AI workflows.](/agentkit/connectors/calmcp/) [OAuth 2.1/DCR](/agentkit/connectors/calmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/calendly.svg)](/agentkit/connectors/calendly/) [Calendly connector](/agentkit/connectors/calendly/) [Connect to Calendly. Access user profile, events, and scheduling workflows.](/agentkit/connectors/calendly/) [OAuth 2.0](/agentkit/connectors/calendly/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/calendly.svg)](/agentkit/connectors/calendlymcp/) [Calendly MCP connector](/agentkit/connectors/calendlymcp/) [Connect to the Calendly MCP server to manage scheduled events, invitees, event types, and availability directly from your AI workflows.](/agentkit/connectors/calendlymcp/) [OAuth 2.1/DCR](/agentkit/connectors/calendlymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/carta.svg)](/agentkit/connectors/cartamcp/) [Carta MCP connector](/agentkit/connectors/cartamcp/) [Connect to Carta. Manage equity cap tables, fund administration, company accounts, and ownership data for venture-backed companies.](/agentkit/connectors/cartamcp/) [OAuth 2.1/DCR](/agentkit/connectors/cartamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/chilipiper.svg)](/agentkit/connectors/chilipipermcp/) [ChiliPiper MCP connector](/agentkit/connectors/chilipipermcp/) [Connect to ChiliPiper MCP. Schedule meetings, manage routing rules, track distributions, and automate handoffs from your AI agents.](/agentkit/connectors/chilipipermcp/) [Bearer Token](/agentkit/connectors/chilipipermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/circleback.svg)](/agentkit/connectors/circlebackmcp/) [Circleback MCP connector](/agentkit/connectors/circlebackmcp/) [Circleback is an AI meeting notes and conversation intelligence platform. The Circleback MCP server provides a standardized interface that allows any...](/agentkit/connectors/circlebackmcp/) [OAuth 2.1/DCR](/agentkit/connectors/circlebackmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/claap.svg)](/agentkit/connectors/claapmcp/) [Claap MCP connector](/agentkit/connectors/claapmcp/) [Video collaboration platform for recording, sharing, and discussing async video clips — used for meeting recordings, product demos, feedback, and team...](/agentkit/connectors/claapmcp/) [OAuth2.1/DCR](/agentkit/connectors/claapmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clarify.svg)](/agentkit/connectors/clarifymcp/) [Clarify MCP connector](/agentkit/connectors/clarifymcp/) [Connect to Clarify MCP to manage CRM records, leads, campaigns, lists, and analytics directly from your AI workflows.](/agentkit/connectors/clarifymcp/) [OAuth 2.1/DCR](/agentkit/connectors/clarifymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clickup.svg)](/agentkit/connectors/clickup/) [ClickUp connector](/agentkit/connectors/clickup/) [Connect to ClickUp. Manage tasks, projects, workspaces, and team collaboration](/agentkit/connectors/clickup/) [OAuth 2.0](/agentkit/connectors/clickup/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/cloudpress.svg)](/agentkit/connectors/cloudpressmcp/) [Cloudpress MCP connector](/agentkit/connectors/cloudpressmcp/) [Cloudpress is a managed WordPress hosting platform built for the AI era. Its MCP server lets AI agents manage sites, domains, DNS, security rules...](/agentkit/connectors/cloudpressmcp/) [OAuth 2.1/DCR](/agentkit/connectors/cloudpressmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/contentful.svg)](/agentkit/connectors/contentfulmcp/) [Contentful MCP connector](/agentkit/connectors/contentfulmcp/) [Connect to Contentful MCP. Manage spaces, entries, assets, content types, and taxonomies in your Contentful CMS from AI workflows.](/agentkit/connectors/contentfulmcp/) [OAuth 2.1/DCR](/agentkit/connectors/contentfulmcp/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/context7.svg)](/agentkit/connectors/context7mcp/) [Context7 MCP connector](/agentkit/connectors/context7mcp/) [Connect to Context7 MCP to fetch up-to-date, version-specific library documentation and code examples directly from the source.](/agentkit/connectors/context7mcp/) [API Key](/agentkit/connectors/context7mcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/conversiontools.svg)](/agentkit/connectors/conversiontoolsmcp/) [Conversion Tools MCP connector](/agentkit/connectors/conversiontoolsmcp/) [Connect to Conversion Tools MCP. Convert files between 140+ formats including documents, images, audio, video, and data files from your AI workflows.](/agentkit/connectors/conversiontoolsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/conversiontoolsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dartai.svg)](/agentkit/connectors/dartaimcp/) [Dart AI MCP connector](/agentkit/connectors/dartaimcp/) [AI-native project management tool for task and document management with deep AI integration.](/agentkit/connectors/dartaimcp/) [OAuth2.1/DCR](/agentkit/connectors/dartaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/deel.svg)](/agentkit/connectors/deelmcp/) [Deel MCP connector](/agentkit/connectors/deelmcp/) [Global HR and payroll platform for hiring, paying, and managing international employees and contractors with built-in compliance.](/agentkit/connectors/deelmcp/) [OAuth2.1/DCR](/agentkit/connectors/deelmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/descript.svg)](/agentkit/connectors/descriptmcp/) [Descript MCP connector](/agentkit/connectors/descriptmcp/) [Connect to Descript MCP. Import media, export transcripts, publish projects, run AI editing agents, and manage jobs from your AI workflows.](/agentkit/connectors/descriptmcp/) [OAuth 2.1/DCR](/agentkit/connectors/descriptmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/diarize.svg)](/agentkit/connectors/diarize/) [Diarize connector](/agentkit/connectors/diarize/) [Connect to Diarize to transcribe and diarize audio and video content from YouTube, X, Instagram, and TikTok. Submit transcription jobs and retrieve...](/agentkit/connectors/diarize/) [Bearer Token](/agentkit/connectors/diarize/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/drop_box.svg)](/agentkit/connectors/dropboxmcp/) [Dropbox MCP connector](/agentkit/connectors/dropboxmcp/) [Connect to Dropbox. Manage files and folders, create shared links, search content, and handle file requests from your AI workflows.](/agentkit/connectors/dropboxmcp/) [OAuth 2.1](/agentkit/connectors/dropboxmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/eracontext.svg)](/agentkit/connectors/eracontextmcp/) [Era Context MCP connector](/agentkit/connectors/eracontextmcp/) [Connect to Era Context MCP. Access personal finance data including transactions, accounts, spending insights, and AI-powered financial knowledge from Era.](/agentkit/connectors/eracontextmcp/) [OAuth 2.1/DCR](/agentkit/connectors/eracontextmcp/) [![](https://docs.excalidraw.com/img/logo.svg)](/agentkit/connectors/excalidrawmcp/) [Excalidraw MCP connector](/agentkit/connectors/excalidrawmcp/) [Excalidraw+ is a collaborative whiteboard and diagramming platform. The Excalidraw MCP server lets AI agents manage scenes, collections, workspaces...](/agentkit/connectors/excalidrawmcp/) [Bearer Token](/agentkit/connectors/excalidrawmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fathom.svg)](/agentkit/connectors/fathommcp/) [Fathom MCP connector](/agentkit/connectors/fathommcp/) [Connect to Fathom MCP to access AI meeting notes, summaries, transcripts, and recordings from your AI workflows.](/agentkit/connectors/fathommcp/) [OAuth 2.1/DCR](/agentkit/connectors/fathommcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fellowai.svg)](/agentkit/connectors/fellowaimcp/) [FellowAI MCP connector](/agentkit/connectors/fellowaimcp/) [Connect to Fellow.ai MCP to manage meeting notes, action items, agendas, and team collaboration workflows directly from your AI agent.](/agentkit/connectors/fellowaimcp/) [OAuth 2.1/DCR](/agentkit/connectors/fellowaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fibery.svg)](/agentkit/connectors/fiberymcp/) [Fibery MCP connector](/agentkit/connectors/fiberymcp/) [Connect to Fibery MCP. Query, create, and update entities across your Fibery workspace using the Fibery API and AI assistant.](/agentkit/connectors/fiberymcp/) [OAuth 2.1/DCR](/agentkit/connectors/fiberymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fireflies.svg)](/agentkit/connectors/firefliesmcp/) [Fireflies MCP connector](/agentkit/connectors/firefliesmcp/) [Connect to Fireflies MCP. Search meeting transcripts, fetch recordings, manage channels, create soundbites, and retrieve analytics from your AI workflows.](/agentkit/connectors/firefliesmcp/) [OAuth 2.1/DCR](/agentkit/connectors/firefliesmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/googlelooker.svg)](/agentkit/connectors/googlelooker/) [Google Looker connector](/agentkit/connectors/googlelooker/) [Connect to Google Looker or self-hosted Looker Core. Browse dashboards, run Looks, query LookML models, and access BI data programmatically.](/agentkit/connectors/googlelooker/) [OAuth 2.0](/agentkit/connectors/googlelooker/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/google.svg)](/agentkit/connectors/googledwd/) [Google Workspace (DWD) connector](/agentkit/connectors/googledwd/) [Connect to Google Workspace APIs (Gmail, Drive, Docs, Sheets, Slides, Forms) using a GCP service account with Domain-Wide Delegation for server-to-server...](/agentkit/connectors/googledwd/) [Service Account (DWD)](/agentkit/connectors/googledwd/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gusto.svg)](/agentkit/connectors/gustomcp/) [Gusto MCP connector](/agentkit/connectors/gustomcp/) [Connect to Gusto MCP. Manage employees, contractors, payroll, departments, and company data from your AI workflows.](/agentkit/connectors/gustomcp/) [OAuth 2.1/DCR](/agentkit/connectors/gustomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/harvestapp.svg)](/agentkit/connectors/harvestmcp/) [Harvest MCP connector](/agentkit/connectors/harvestmcp/) [Harvest is a time tracking and invoicing tool that helps teams track time, manage projects, and create invoices.](/agentkit/connectors/harvestmcp/) [OAuth2.1/DCR](/agentkit/connectors/harvestmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/igpt.svg)](/agentkit/connectors/igptmcp/) [IGPT MCP connector](/agentkit/connectors/igptmcp/) [IGPT is an AI assistant platform that exposes its capabilities via an MCP server, enabling agents to interact with AI-powered tools and workflows.](/agentkit/connectors/igptmcp/) [OAuth2.1/DCR](/agentkit/connectors/igptmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jotform.svg)](/agentkit/connectors/jotformmcp/) [Jotform MCP connector](/agentkit/connectors/jotformmcp/) [Connect to Jotform MCP. Create and edit forms, retrieve submissions, assign forms, and search assets from your AI workflows.](/agentkit/connectors/jotformmcp/) [OAuth 2.1/DCR](/agentkit/connectors/jotformmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/loops.svg)](/agentkit/connectors/loopsmcp/) [Loops MCP connector](/agentkit/connectors/loopsmcp/) [Connect to Loops MCP. Create and manage loops and tasks, set priorities, track work queue stats, and ship completed loops from your AI workflows.](/agentkit/connectors/loopsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/loopsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lucid.svg)](/agentkit/connectors/lucidmcp/) [Lucid MCP connector](/agentkit/connectors/lucidmcp/) [Connect to Lucid. Create and edit Lucidchart diagrams, Lucidspark boards, and Lucidscale visualizations from your AI workflows.](/agentkit/connectors/lucidmcp/) [OAuth 2.1/DCR](/agentkit/connectors/lucidmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/make.svg)](/agentkit/connectors/makemcp/) [Make MCP connector](/agentkit/connectors/makemcp/) [Connect to Make (formerly Integromat). Build, run, and manage automation scenarios, data stores, webhooks, and connections across thousands of apps from...](/agentkit/connectors/makemcp/) [OAuth 2.1/DCR](/agentkit/connectors/makemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mem.svg)](/agentkit/connectors/memmcp/) [Mem MCP connector](/agentkit/connectors/memmcp/) [A hosted MCP server that gives AI tools secure access to your Mem notes and collections — enabling AI agents to read, create, search, and organize notes...](/agentkit/connectors/memmcp/) [OAuth2.1/DCR](/agentkit/connectors/memmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mercury.svg)](/agentkit/connectors/mercurymcp/) [Mercury MCP connector](/agentkit/connectors/mercurymcp/) [Connect to Mercury. Access accounts, transactions, recipients, invoices, treasury, webhooks, and approval requests for startup banking workflows.](/agentkit/connectors/mercurymcp/) [OAuth 2.1/DCR](/agentkit/connectors/mercurymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/metaview.svg)](/agentkit/connectors/metaviewmcp/) [Metaview MCP connector](/agentkit/connectors/metaviewmcp/) [Metaview is an agentic recruiting platform that automates end-to-end hiring workflows — from candidate sourcing and outreach to interview note-taking and...](/agentkit/connectors/metaviewmcp/) [OAuth 2.1/DCR](/agentkit/connectors/metaviewmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/microsoft365.svg)](/agentkit/connectors/microsoft365/) [Microsoft 365 connector](/agentkit/connectors/microsoft365/) [Connect to Microsoft 365. Unified access to Outlook, Excel, Word, OneNote, OneDrive, SharePoint, and Teams through Microsoft Graph API.](/agentkit/connectors/microsoft365/) [OAuth 2.0](/agentkit/connectors/microsoft365/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mintlify.svg)](/agentkit/connectors/mintlifymcp/) [Mintlify MCP connector](/agentkit/connectors/mintlifymcp/) [Connect to Mintlify MCP. Read and edit documentation pages, manage navigation nodes, search content, and publish changes via pull requests from your AI...](/agentkit/connectors/mintlifymcp/) [OAuth 2.1/DCR](/agentkit/connectors/mintlifymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/Miro.svg)](/agentkit/connectors/miro/) [Miro connector](/agentkit/connectors/miro/) [Miro is a visual collaboration platform for teams. Manage boards, sticky notes, shapes, cards, frames, connectors, images, and tags using the Miro REST...](/agentkit/connectors/miro/) [OAuth 2.0](/agentkit/connectors/miro/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/Miro.svg)](/agentkit/connectors/miromcp/) [Miro MCP connector](/agentkit/connectors/miromcp/) [Connect to Miro MCP to create and manage boards, frames, sticky notes, shapes, diagrams, and comments directly from your AI workflows.](/agentkit/connectors/miromcp/) [OAuth 2.1/DCR](/agentkit/connectors/miromcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/monday.svg)](/agentkit/connectors/mondaymcp/) [Monday MCP connector](/agentkit/connectors/mondaymcp/) [Connect to the monday.com MCP server to manage boards, items, columns, docs, and workflows directly from your AI agents.](/agentkit/connectors/mondaymcp/) [OAuth 2.1/DCR](/agentkit/connectors/mondaymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/monday.svg)](/agentkit/connectors/monday/) [Monday.com connector](/agentkit/connectors/monday/) [Connect to Monday.com. Manage boards, tasks, workflows, teams, and project collaboration](/agentkit/connectors/monday/) [OAuth 2.0](/agentkit/connectors/monday/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/motion.svg)](/agentkit/connectors/motionmcp/) [Motion MCP connector](/agentkit/connectors/motionmcp/) [Connect to Motion MCP. Manage tasks, projects, workspaces, and schedules in the Motion AI-powered project management platform.](/agentkit/connectors/motionmcp/) [OAuth 2.1/DCR](/agentkit/connectors/motionmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/netlify.svg)](/agentkit/connectors/netlifymcp/) [Netlify MCP connector](/agentkit/connectors/netlifymcp/) [Build, deploy, and manage Netlify projects — sites, functions, environment variables, forms, blobs, and edge functions — from AI agents via the Netlify...](/agentkit/connectors/netlifymcp/) [OAuth 2.1/DCR](/agentkit/connectors/netlifymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/nocodb.svg)](/agentkit/connectors/nocodbmcp/) [NocoDB MCP connector](/agentkit/connectors/nocodbmcp/) [Connect to NocoDB MCP. Create and manage databases, tables, records, views, and fields from your AI workflows.](/agentkit/connectors/nocodbmcp/) [OAuth 2.1/DCR](/agentkit/connectors/nocodbmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/notion.svg)](/agentkit/connectors/notionmcp/) [Notion MCP connector](/agentkit/connectors/notionmcp/) [Connect to Notion MCP. Create and update pages, databases, comments, and views from your AI workflows.](/agentkit/connectors/notionmcp/) [OAuth 2.1/DCR](/agentkit/connectors/notionmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/otterai.svg)](/agentkit/connectors/otteraimcp/) [OtterAI MCP connector](/agentkit/connectors/otteraimcp/) [Connect to OtterAI MCP. Search meeting recordings, fetch full transcripts, and retrieve user account info from your AI workflows.](/agentkit/connectors/otteraimcp/) [OAuth 2.1/DCR](/agentkit/connectors/otteraimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pandadoc.svg)](/agentkit/connectors/pandadocmcp/) [Pandadoc MCP connector](/agentkit/connectors/pandadocmcp/) [Connect to PandaDoc MCP. Create, send, and manage documents, templates, and e-signatures directly from your AI workflows.](/agentkit/connectors/pandadocmcp/) [OAuth 2.1/DCR](/agentkit/connectors/pandadocmcp/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/parallel-ai.svg)](/agentkit/connectors/parallelaitaskmcp/) [Parallel AI Task MCP connector](/agentkit/connectors/parallelaitaskmcp/) [Connect to Parallel AI Task MCP to run deep research tasks and task groups directly from your AI workflows.](/agentkit/connectors/parallelaitaskmcp/) [Bearer Token](/agentkit/connectors/parallelaitaskmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/plain.svg)](/agentkit/connectors/plainmcp/) [Plain MCP connector](/agentkit/connectors/plainmcp/) [Connect to Plain MCP. Manage customer support threads, labels, tenants, Help Center articles, and thread field schemas directly from your AI workflows.](/agentkit/connectors/plainmcp/) [OAuth 2.1/DCR](/agentkit/connectors/plainmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/plane.svg)](/agentkit/connectors/planemcp/) [Plane MCP connector](/agentkit/connectors/planemcp/) [Connect to Plane MCP. Manage projects, work items, cycles, modules, epics, and initiatives in your Plane workspace from AI workflows.](/agentkit/connectors/planemcp/) [OAuth 2.1/DCR](/agentkit/connectors/planemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/planningcenter.svg)](/agentkit/connectors/planningcentermcp/) [Planning Center MCP connector](/agentkit/connectors/planningcentermcp/) [Planning Center is a church management platform with modules for people (contact database), giving, check-ins, services planning, groups, registrations...](/agentkit/connectors/planningcentermcp/) [OAuth 2.1/DCR](/agentkit/connectors/planningcentermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/privacy.svg)](/agentkit/connectors/privacymcp/) [Privacy MCP connector](/agentkit/connectors/privacymcp/) [Connect to Privacy MCP. Create and manage virtual cards, set spend limits, pause or close cards, and review transactions from your AI workflows.](/agentkit/connectors/privacymcp/) [OAuth 2.1/DCR](/agentkit/connectors/privacymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/quizvideo.svg)](/agentkit/connectors/quizvideomcp/) [Quiz.Video MCP connector](/agentkit/connectors/quizvideomcp/) [Quiz.Video is an AI-powered platform for creating short-form quiz and flashcard videos. Transform topics, URLs, or documents into shareable quiz and...](/agentkit/connectors/quizvideomcp/) [OAuth 2.1/DCR](/agentkit/connectors/quizvideomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/readai.svg)](/agentkit/connectors/readaimcp/) [Read AI MCP connector](/agentkit/connectors/readaimcp/) [Connect to Read AI to access your meeting intelligence — transcripts, summaries, action items, and insights from meetings, emails, and chats. Retrieve...](/agentkit/connectors/readaimcp/) [OAuth2.1/DCR](/agentkit/connectors/readaimcp/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/rize.svg)](/agentkit/connectors/rizemcp/) [Rize MCP connector](/agentkit/connectors/rizemcp/) [Connect to Rize MCP using OAuth 2.1 with MCP discovery and dynamic client registration. Access and analyze your time tracking data, projects, clients...](/agentkit/connectors/rizemcp/) [OAuth 2.1/DCR](/agentkit/connectors/rizemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sanity.svg)](/agentkit/connectors/sanitymcp/) [Sanity MCP connector](/agentkit/connectors/sanitymcp/) [Connect to Sanity. Manage structured content, documents, datasets, schemas, releases, and media assets for headless CMS workflows.](/agentkit/connectors/sanitymcp/) [OAuth 2.1/DCR](/agentkit/connectors/sanitymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/send.svg)](/agentkit/connectors/sendmcp/) [Send MCP connector](/agentkit/connectors/sendmcp/) [Connect to Send to create, edit, and share Claude-generated documents as polished web pages with engagement tracking, custom domains, and team asset...](/agentkit/connectors/sendmcp/) [OAuth2.1/DCR](/agentkit/connectors/sendmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/signwell.svg)](/agentkit/connectors/signwell/) [SignWell connector](/agentkit/connectors/signwell/) [SignWell is an e-signature platform for sending, signing, and managing documents. Connect to create and send documents for signature, manage templates...](/agentkit/connectors/signwell/) [API Key](/agentkit/connectors/signwell/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/slack.svg)](/agentkit/connectors/slackmcp/) [Slack MCP connector](/agentkit/connectors/slackmcp/) [Connect to Slack MCP. Send and read messages, search channels and users, manage canvases, and react to messages across your Slack workspace.](/agentkit/connectors/slackmcp/) [OAuth 2.1](/agentkit/connectors/slackmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/sleekplan.svg)](/agentkit/connectors/sleekplanmcp/) [Sleekplan MCP connector](/agentkit/connectors/sleekplanmcp/) [Sleekplan is a customer feedback, feature request, and roadmap management platform.](/agentkit/connectors/sleekplanmcp/) [OAuth2.1/DCR](/agentkit/connectors/sleekplanmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/slite.svg)](/agentkit/connectors/slitemcp/) [Slite MCP connector](/agentkit/connectors/slitemcp/) [Connect to Slite MCP. Create and manage notes, channels, collections, and comments in Slite from AI workflows.](/agentkit/connectors/slitemcp/) [OAuth 2.1/DCR](/agentkit/connectors/slitemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/splice.svg)](/agentkit/connectors/splicemcp/) [Splice MCP connector](/agentkit/connectors/splicemcp/) [Connect to Splice MCP. Search the Splice sample catalog, create and update multi-track stacks, download audio assets, and generate arrangements from text...](/agentkit/connectors/splicemcp/) [OAuth 2.1/DCR](/agentkit/connectors/splicemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/swagger.svg)](/agentkit/connectors/swaggermcp/) [Swagger MCP connector](/agentkit/connectors/swaggermcp/) [Connect to Swagger MCP. Create and manage APIs, developer portals, and documentation in SwaggerHub from AI workflows.](/agentkit/connectors/swaggermcp/) [OAuth 2.1/DCR](/agentkit/connectors/swaggermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tableau.svg)](/agentkit/connectors/tableau/) [Tableau connector](/agentkit/connectors/tableau/) [Connect to Tableau Cloud or Tableau Server to browse workbooks, views, and data sources, export visualizations, and query underlying data.](/agentkit/connectors/tableau/) [API Key](/agentkit/connectors/tableau/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tactiq.svg)](/agentkit/connectors/tactiqmcp/) [Tactiq MCP connector](/agentkit/connectors/tactiqmcp/) [Tactiq captures and transcribes meetings in real time, turning conversations into AI-generated notes, summaries, and action items.](/agentkit/connectors/tactiqmcp/) [OAuth2.1/DCR](/agentkit/connectors/tactiqmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tally.svg)](/agentkit/connectors/tallymcp/) [Tally MCP connector](/agentkit/connectors/tallymcp/) [Connect to Tally MCP. Create and edit forms, manage submissions, and update styling and logic in your Tally workspace from AI workflows.](/agentkit/connectors/tallymcp/) [OAuth 2.1/DCR](/agentkit/connectors/tallymcp/) [![]()](/agentkit/connectors/ticktickmcp/) [TickTick MCP connector](/agentkit/connectors/ticktickmcp/) [Connect to TickTick MCP. Manage tasks, projects, habits, and focus sessions in your TickTick account from AI workflows.](/agentkit/connectors/ticktickmcp/) [OAuth 2.1/DCR](/agentkit/connectors/ticktickmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/todoist.svg)](/agentkit/connectors/todoistmcp/) [Todoist MCP connector](/agentkit/connectors/todoistmcp/) [Connect to Todoist MCP. Manage tasks, projects, sections, labels, filters, goals, and reminders from your AI workflows.](/agentkit/connectors/todoistmcp/) [OAuth 2.1/DCR](/agentkit/connectors/todoistmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/topcounsel.svg)](/agentkit/connectors/topcounselmcp/) [TopCounsel MCP connector](/agentkit/connectors/topcounselmcp/) [Connect to TopCounsel by The L Suite to search, shortlist, and compare peer-vetted outside counsel recommendations grounded in firsthand feedback from...](/agentkit/connectors/topcounselmcp/) [OAuth 2.1/DCR](/agentkit/connectors/topcounselmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/trello_n.svg)](/agentkit/connectors/trello/) [Trello connector](/agentkit/connectors/trello/) [Connect to Trello. Manage boards, cards, lists, and team collaboration workflows](/agentkit/connectors/trello/) [OAuth 1.0a](/agentkit/connectors/trello/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/typeform.svg)](/agentkit/connectors/typeformmcp/) [Typeform MCP connector](/agentkit/connectors/typeformmcp/) [Connect to Typeform MCP to create and manage forms, read responses, and manage workspaces, contacts, and webhooks directly from your AI workflows.](/agentkit/connectors/typeformmcp/) [OAuth 2.1/DCR](/agentkit/connectors/typeformmcp/) [![](https://framerusercontent.com/images/Pl7PUhW6GIt6eumE6hy3eKACaA.png)](/agentkit/connectors/upstreammcp/) [Upstream MCP connector](/agentkit/connectors/upstreammcp/) [Connect to Upstream MCP to access AI-assistant tools and workflows, including inbox management, directly from your AI workflows.](/agentkit/connectors/upstreammcp/) [Bearer Token](/agentkit/connectors/upstreammcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/vercel.svg)](/agentkit/connectors/vercelmcp/) [Vercel MCP connector](/agentkit/connectors/vercelmcp/) [Connect to Vercel MCP to manage deployments, projects, domains, environment variables, and team resources directly from your AI workflows.](/agentkit/connectors/vercelmcp/) [OAuth 2.1](/agentkit/connectors/vercelmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/webflow.svg)](/agentkit/connectors/webflowmcp/) [Webflow MCP connector](/agentkit/connectors/webflowmcp/) [Connect to Webflow. Build and manage websites, pages, components, styles, assets, CMS collections, and site settings through the Webflow Designer and Data...](/agentkit/connectors/webflowmcp/) [OAuth 2.1/DCR](/agentkit/connectors/webflowmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/whimsical.svg)](/agentkit/connectors/whimsicalmcp/) [Whimsical MCP connector](/agentkit/connectors/whimsicalmcp/) [Connect to Whimsical MCP. Create and edit flowcharts, mind maps, wireframes, and docs, and manage boards, comments, and workspaces from your AI workflows.](/agentkit/connectors/whimsicalmcp/) [OAuth 2.1/DCR](/agentkit/connectors/whimsicalmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/whop.svg)](/agentkit/connectors/whopmcp/) [Whop MCP connector](/agentkit/connectors/whopmcp/) [Whop is a platform for selling digital products, memberships, and communities.](/agentkit/connectors/whopmcp/) [OAuth2.1/DCR](/agentkit/connectors/whopmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/wix.svg)](/agentkit/connectors/wixmcp/) [Wix MCP connector](/agentkit/connectors/wixmcp/) [Connect to Wix MCP. Build and manage Wix sites, call REST APIs, search documentation, upload media, and suggest domains from your AI workflows.](/agentkit/connectors/wixmcp/) [OAuth 2.1/DCR](/agentkit/connectors/wixmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/zapier.svg)](/agentkit/connectors/zapiermcp/) [Zapier MCP connector](/agentkit/connectors/zapiermcp/) [Connect to Zapier MCP to automate workflows and integrate with thousands of apps directly from your AI agent.](/agentkit/connectors/zapiermcp/) [OAuth 2.1/DCR](/agentkit/connectors/zapiermcp/) ## Project Management [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airtable.svg)](/agentkit/connectors/airtable/) [Airtable connector](/agentkit/connectors/airtable/) [Connect to Airtable. Manage databases, tables, records, and collaborate on structured data](/agentkit/connectors/airtable/) [OAuth 2.0](/agentkit/connectors/airtable/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/airtable.svg)](/agentkit/connectors/airtablemcp/) [Airtable MCP connector](/agentkit/connectors/airtablemcp/) [Connect to Airtable MCP. Manage bases, tables, records, views, fields, and automations from your AI workflows.](/agentkit/connectors/airtablemcp/) [OAuth 2.1/DCR](/agentkit/connectors/airtablemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/asana-n.svg)](/agentkit/connectors/asana/) [Asana connector](/agentkit/connectors/asana/) [Connect to Asana. Manage tasks, projects, teams, and workflow automation](/agentkit/connectors/asana/) [OAuth 2.0](/agentkit/connectors/asana/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/asana-n.svg)](/agentkit/connectors/asanamcp/) [Asana MCP connector](/agentkit/connectors/asanamcp/) [Connect to Asana MCP server to manage tasks, projects, and teams directly from your AI workflows.](/agentkit/connectors/asanamcp/) [OAuth 2.1](/agentkit/connectors/asanamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/atlassian.svg)](/agentkit/connectors/atlassianmcp/) [Atlassian Rovo MCP connector](/agentkit/connectors/atlassianmcp/) [Connect to Atlassian Rovo MCP server to manage Jira issues, Confluence pages, and Compass components directly from your AI workflows.](/agentkit/connectors/atlassianmcp/) [OAuth 2.1/DCR](/agentkit/connectors/atlassianmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/bonsai.svg)](/agentkit/connectors/bonsaimcp/) [Bonsai MCP connector](/agentkit/connectors/bonsaimcp/) [Connect to Bonsai, the all-in-one business management platform for freelancers and agencies. Manage projects, tasks, CRM contacts, deals, invoices, and...](/agentkit/connectors/bonsaimcp/) [OAuth2.1/DCR](/agentkit/connectors/bonsaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clickup.svg)](/agentkit/connectors/clickup/) [ClickUp connector](/agentkit/connectors/clickup/) [Connect to ClickUp. Manage tasks, projects, workspaces, and team collaboration](/agentkit/connectors/clickup/) [OAuth 2.0](/agentkit/connectors/clickup/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/confluence.svg)](/agentkit/connectors/confluence/) [Confluence connector](/agentkit/connectors/confluence/) [Connect to Confluence. Manage spaces, pages, content, and team collaboration](/agentkit/connectors/confluence/) [OAuth 2.0](/agentkit/connectors/confluence/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/dartai.svg)](/agentkit/connectors/dartaimcp/) [Dart AI MCP connector](/agentkit/connectors/dartaimcp/) [AI-native project management tool for task and document management with deep AI integration.](/agentkit/connectors/dartaimcp/) [OAuth2.1/DCR](/agentkit/connectors/dartaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fellowai.svg)](/agentkit/connectors/fellowaimcp/) [FellowAI MCP connector](/agentkit/connectors/fellowaimcp/) [Connect to Fellow.ai MCP to manage meeting notes, action items, agendas, and team collaboration workflows directly from your AI agent.](/agentkit/connectors/fellowaimcp/) [OAuth 2.1/DCR](/agentkit/connectors/fellowaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fibery.svg)](/agentkit/connectors/fiberymcp/) [Fibery MCP connector](/agentkit/connectors/fiberymcp/) [Connect to Fibery MCP. Query, create, and update entities across your Fibery workspace using the Fibery API and AI assistant.](/agentkit/connectors/fiberymcp/) [OAuth 2.1/DCR](/agentkit/connectors/fiberymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/harvestapp.svg)](/agentkit/connectors/harvestmcp/) [Harvest MCP connector](/agentkit/connectors/harvestmcp/) [Harvest is a time tracking and invoicing tool that helps teams track time, manage projects, and create invoices.](/agentkit/connectors/harvestmcp/) [OAuth2.1/DCR](/agentkit/connectors/harvestmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jira.svg)](/agentkit/connectors/jira/) [Jira connector](/agentkit/connectors/jira/) [Connect to Jira. Manage issues, projects, workflows, and agile development processes](/agentkit/connectors/jira/) [OAuth 2.0](/agentkit/connectors/jira/) [![](https://wac-cdn.atlassian.com/dam/jcr:be09430e-3f78-4712-a953-ddcbe01ea541/jsd-icon.svg?cdnVersion=3478)](/agentkit/connectors/jiraservicemanagement/) [Jira Service Management connector](/agentkit/connectors/jiraservicemanagement/) [Connect to Jira Service Management. Manage customer requests, service desks, organizations, knowledge base articles, SLAs, and queues](/agentkit/connectors/jiraservicemanagement/) [OAuth 2.0](/agentkit/connectors/jiraservicemanagement/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/linear.svg)](/agentkit/connectors/linear/) [Linear connector](/agentkit/connectors/linear/) [Connect to Linear. Manage issues, projects, sprints, and development workflows](/agentkit/connectors/linear/) [OAuth 2.0](/agentkit/connectors/linear/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/linear.svg)](/agentkit/connectors/linearmcp/) [Linear MCP connector](/agentkit/connectors/linearmcp/) [Connect to Linear's hosted MCP server to manage issues, projects, cycles, and comments directly from your AI workflows.](/agentkit/connectors/linearmcp/) [OAuth 2.1/DCR](/agentkit/connectors/linearmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/loops.svg)](/agentkit/connectors/loopsmcp/) [Loops MCP connector](/agentkit/connectors/loopsmcp/) [Connect to Loops MCP. Create and manage loops and tasks, set priorities, track work queue stats, and ship completed loops from your AI workflows.](/agentkit/connectors/loopsmcp/) [OAuth 2.1/DCR](/agentkit/connectors/loopsmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/monday.svg)](/agentkit/connectors/mondaymcp/) [Monday MCP connector](/agentkit/connectors/mondaymcp/) [Connect to the monday.com MCP server to manage boards, items, columns, docs, and workflows directly from your AI agents.](/agentkit/connectors/mondaymcp/) [OAuth 2.1/DCR](/agentkit/connectors/mondaymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/monday.svg)](/agentkit/connectors/monday/) [Monday.com connector](/agentkit/connectors/monday/) [Connect to Monday.com. Manage boards, tasks, workflows, teams, and project collaboration](/agentkit/connectors/monday/) [OAuth 2.0](/agentkit/connectors/monday/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/motion.svg)](/agentkit/connectors/motionmcp/) [Motion MCP connector](/agentkit/connectors/motionmcp/) [Connect to Motion MCP. Manage tasks, projects, workspaces, and schedules in the Motion AI-powered project management platform.](/agentkit/connectors/motionmcp/) [OAuth 2.1/DCR](/agentkit/connectors/motionmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/notion.svg)](/agentkit/connectors/notion/) [Notion connector](/agentkit/connectors/notion/) [Connect to Notion workspace. Create, edit pages, manage databases, and collaborate on content](/agentkit/connectors/notion/) [OAuth 2.0](/agentkit/connectors/notion/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/notion.svg)](/agentkit/connectors/notionmcp/) [Notion MCP connector](/agentkit/connectors/notionmcp/) [Connect to Notion MCP. Create and update pages, databases, comments, and views from your AI workflows.](/agentkit/connectors/notionmcp/) [OAuth 2.1/DCR](/agentkit/connectors/notionmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/plane.svg)](/agentkit/connectors/planemcp/) [Plane MCP connector](/agentkit/connectors/planemcp/) [Connect to Plane MCP. Manage projects, work items, cycles, modules, epics, and initiatives in your Plane workspace from AI workflows.](/agentkit/connectors/planemcp/) [OAuth 2.1/DCR](/agentkit/connectors/planemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/pylon.svg)](/agentkit/connectors/pylonmcp/) [Pylon MCP connector](/agentkit/connectors/pylonmcp/) [Connect to Pylon MCP. Manage customer issues, accounts, projects, milestones, and tasks from your AI workflows.](/agentkit/connectors/pylonmcp/) [OAuth 2.1/DCR](/agentkit/connectors/pylonmcp/) [![]()](/agentkit/connectors/ticktickmcp/) [TickTick MCP connector](/agentkit/connectors/ticktickmcp/) [Connect to TickTick MCP. Manage tasks, projects, habits, and focus sessions in your TickTick account from AI workflows.](/agentkit/connectors/ticktickmcp/) [OAuth 2.1/DCR](/agentkit/connectors/ticktickmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/todoist.svg)](/agentkit/connectors/todoistmcp/) [Todoist MCP connector](/agentkit/connectors/todoistmcp/) [Connect to Todoist MCP. Manage tasks, projects, sections, labels, filters, goals, and reminders from your AI workflows.](/agentkit/connectors/todoistmcp/) [OAuth 2.1/DCR](/agentkit/connectors/todoistmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/trello_n.svg)](/agentkit/connectors/trello/) [Trello connector](/agentkit/connectors/trello/) [Connect to Trello. Manage boards, cards, lists, and team collaboration workflows](/agentkit/connectors/trello/) [OAuth 1.0a](/agentkit/connectors/trello/) ## Search [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/alphaxiv.svg)](/agentkit/connectors/alphaxivmcp/) [AlphaXiv MCP connector](/agentkit/connectors/alphaxivmcp/) [Connect to AlphaXiv MCP to search and retrieve arXiv research papers, abstracts, authors, and citations from your AI workflows.](/agentkit/connectors/alphaxivmcp/) [OAuth 2.1/DCR](/agentkit/connectors/alphaxivmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/biorendermcp.svg)](/agentkit/connectors/biorendermcp/) [Bio Render MCP connector](/agentkit/connectors/biorendermcp/) [Connect to BioRender MCP. Search BioRender's scientific icon and figure template libraries to build publication-ready biological illustrations.](/agentkit/connectors/biorendermcp/) [OAuth 2.1/DCR](/agentkit/connectors/biorendermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/biomni.svg)](/agentkit/connectors/biomnimcp/) [Biomni MCP connector](/agentkit/connectors/biomnimcp/) [Connect to Biomni MCP by phylo.bio, an AI biomedical research assistant. Analyze life-sciences data, interpret genomic variants, query curated databases...](/agentkit/connectors/biomnimcp/) [OAuth2.1/DCR](/agentkit/connectors/biomnimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/brave.svg)](/agentkit/connectors/brave/) [Brave Search connector](/agentkit/connectors/brave/) [Connect to Brave Search to perform web, image, video, and news searches with privacy-focused results, plus AI-powered suggestions and spellcheck.](/agentkit/connectors/brave/) [API Key](/agentkit/connectors/brave/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/candid.svg)](/agentkit/connectors/candidmcp/) [Candid MCP connector](/agentkit/connectors/candidmcp/) [Connect to Candid MCP. Search nonprofit organizations, explore philanthropic data, and classify social sector activities using Candid's knowledge base.](/agentkit/connectors/candidmcp/) [OAuth 2.1/DCR](/agentkit/connectors/candidmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/crustdata.svg)](/agentkit/connectors/crustdatamcp/) [Crustdata MCP connector](/agentkit/connectors/crustdatamcp/) [People and company intelligence platform for candidate sourcing, sales prospecting, and talent intelligence. Provides real-time data on professionals...](/agentkit/connectors/crustdatamcp/) [OAuth 2.1/DCR](/agentkit/connectors/crustdatamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/exa.svg)](/agentkit/connectors/exa/) [Exa connector](/agentkit/connectors/exa/) [Connect to Exa to perform AI-powered semantic web search, crawl websites for structured content, get natural language answers from the web, run in-depth...](/agentkit/connectors/exa/) [API Key](/agentkit/connectors/exa/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/exa.svg)](/agentkit/connectors/examcp/) [Exa MCP connector](/agentkit/connectors/examcp/) [Connect to Exa MCP to perform AI-powered semantic web search, crawl websites for structured content, get natural language answers from the web, and run...](/agentkit/connectors/examcp/) [API Key](/agentkit/connectors/examcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fever.svg)](/agentkit/connectors/fevermcp/) [Fever MCP connector](/agentkit/connectors/fevermcp/) [Fever is a live entertainment discovery platform. This MCP connector gives AI assistants direct access to Fever's global event catalog — search events by...](/agentkit/connectors/fevermcp/) [OAuth 2.1/DCR](/agentkit/connectors/fevermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/firecrawl.svg)](/agentkit/connectors/firecrawlmcp/) [Firecrawl MCP connector](/agentkit/connectors/firecrawlmcp/) [Connect to Firecrawl MCP. Scrape, crawl, search, extract structured data, and monitor websites using Firecrawl's AI-powered web scraping API.](/agentkit/connectors/firecrawlmcp/) [Bearer Token](/agentkit/connectors/firecrawlmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/greptile.svg)](/agentkit/connectors/greptilmcp/) [Greptile MCP connector](/agentkit/connectors/greptilmcp/) [AI-powered code search and understanding API that indexes GitHub and GitLab repositories, enabling natural language queries over codebases.](/agentkit/connectors/greptilmcp/) [OAuth2.1/DCR](/agentkit/connectors/greptilmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/legaldatahunter.svg)](/agentkit/connectors/legaldatahuntermcp/) [Legal Data Hunter MCP connector](/agentkit/connectors/legaldatahuntermcp/) [Connect to Legal Data Hunter MCP. Search and explore indexed legal data sources worldwide, tracking case law, courts, dockets, and legal data coverage...](/agentkit/connectors/legaldatahuntermcp/) [OAuth 2.1/DCR](/agentkit/connectors/legaldatahuntermcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mobbins.svg)](/agentkit/connectors/mobbinmcp/) [Mobbin MCP connector](/agentkit/connectors/mobbinmcp/) [Connect to Mobbin's MCP server to search real-world UI and UX design references from mobile apps, web apps, and websites using natural language. Returns...](/agentkit/connectors/mobbinmcp/) [OAuth2.1/DCR](/agentkit/connectors/mobbinmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/mtnewswires.svg)](/agentkit/connectors/mtnewswiresmcp/) [MT Newswires MCP connector](/agentkit/connectors/mtnewswiresmcp/) [Connect to the MT Newswires MCP server on viaNexus to search and retrieve real-time, low-latency financial news across equities, fixed income...](/agentkit/connectors/mtnewswiresmcp/) [OAuth 2.1/DCR](/agentkit/connectors/mtnewswiresmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/nimble.svg)](/agentkit/connectors/nimblemcp/) [Nimble MCP connector](/agentkit/connectors/nimblemcp/) [Connect to Nimble MCP. Search the web across multiple engines, extract content from any URL, crawl websites at scale, discover all URLs on a site, and run...](/agentkit/connectors/nimblemcp/) [Bearer Token](/agentkit/connectors/nimblemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/scrapfly.svg)](/agentkit/connectors/scarpflymcp/) [Scarpfly MCP connector](/agentkit/connectors/scarpflymcp/) [Connect to Scrapfly MCP. Scrape web pages, take screenshots, and control a cloud browser with anti-bot bypass, JS rendering, and proxy support.](/agentkit/connectors/scarpflymcp/) [OAuth 2.1/DCR](/agentkit/connectors/scarpflymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/scholargateway.svg)](/agentkit/connectors/scholargateway/) [Scholar Gateway MCP connector](/agentkit/connectors/scholargateway/) [Connect to Scholar Gateway to search Wiley's peer-reviewed academic literature — 8M+ articles from 2,000+ journals spanning sciences, healthcare...](/agentkit/connectors/scholargateway/) [OAuth2.1/DCR](/agentkit/connectors/scholargateway/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/supadata.svg)](/agentkit/connectors/supadata/) [Supadata connector](/agentkit/connectors/supadata/) [Connect with Supadata to extract transcripts, metadata, and structured content from YouTube, social media, and the web using AI.](/agentkit/connectors/supadata/) [API Key](/agentkit/connectors/supadata/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/supadata.svg)](/agentkit/connectors/supadatamcp/) [Supadata MCP connector](/agentkit/connectors/supadatamcp/) [Connect with Supadata MCP to extract transcripts, metadata, and structured content from YouTube, social media, and the web using AI.](/agentkit/connectors/supadatamcp/) [OAuth 2.1/DCR](/agentkit/connectors/supadatamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/synthesize-bio.svg)](/agentkit/connectors/synthesizebiomcp/) [Synthesize Bio MCP connector](/agentkit/connectors/synthesizebiomcp/) [Connect to Synthesize Bio MCP. Run differential gene expression analysis, resolve sample metadata, and retrieve results and raw counts data from your AI...](/agentkit/connectors/synthesizebiomcp/) [OAuth 2.1/DCR](/agentkit/connectors/synthesizebiomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tango.svg)](/agentkit/connectors/tangomcp/) [Tango MCP connector](/agentkit/connectors/tangomcp/) [Connect to Tango MCP by makegov to search federal contracts, opportunities, vehicles, organizations, and protests, and pull competitive...](/agentkit/connectors/tangomcp/) [API Key](/agentkit/connectors/tangomcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tavily.svg)](/agentkit/connectors/tavilymcp/) [Tavily MCP connector](/agentkit/connectors/tavilymcp/) [Connect to Tavily MCP. Search the web, crawl websites, extract content, map site structure, and run deep research using Tavily's AI-powered search API.](/agentkit/connectors/tavilymcp/) [OAuth 2.1/DCR](/agentkit/connectors/tavilymcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/topcounsel.svg)](/agentkit/connectors/topcounselmcp/) [TopCounsel MCP connector](/agentkit/connectors/topcounselmcp/) [Connect to TopCounsel by The L Suite to search, shortlist, and compare peer-vetted outside counsel recommendations grounded in firsthand feedback from...](/agentkit/connectors/topcounselmcp/) [OAuth 2.1/DCR](/agentkit/connectors/topcounselmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/you.svg)](/agentkit/connectors/youmcp/) [You.com MCP connector](/agentkit/connectors/youmcp/) [Connect to You.com MCP. Search the web, research topics with cited sources, and extract full page content using You.com's AI-powered search and research...](/agentkit/connectors/youmcp/) [Bearer Token](/agentkit/connectors/youmcp/) ## Transcription [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/chorus.svg)](/agentkit/connectors/chorus/) [Chorus connector](/agentkit/connectors/chorus/) [Connect to Chorus.ai to sync calls, transcripts, conversation intelligence, and analytics.](/agentkit/connectors/chorus/) [Basic Auth](/agentkit/connectors/chorus/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/circleback.svg)](/agentkit/connectors/circlebackmcp/) [Circleback MCP connector](/agentkit/connectors/circlebackmcp/) [Circleback is an AI meeting notes and conversation intelligence platform. The Circleback MCP server provides a standardized interface that allows any...](/agentkit/connectors/circlebackmcp/) [OAuth 2.1/DCR](/agentkit/connectors/circlebackmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/clari.svg)](/agentkit/connectors/clari_copilot/) [Clari Copilot connector](/agentkit/connectors/clari_copilot/) [Connect to Clari Copilot for sales call transcripts, analytics, call data, and insights.](/agentkit/connectors/clari_copilot/) [API Key](/agentkit/connectors/clari_copilot/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/deepgram.svg)](/agentkit/connectors/deepgrammcp/) [Deepgram MCP connector](/agentkit/connectors/deepgrammcp/) [Connect to Deepgram MCP. Transcribe audio, generate speech, and manage transcription projects using Deepgram's AI-powered speech recognition API.](/agentkit/connectors/deepgrammcp/) [OAuth 2.1/DCR](/agentkit/connectors/deepgrammcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/diarize.svg)](/agentkit/connectors/diarize/) [Diarize connector](/agentkit/connectors/diarize/) [Connect to Diarize to transcribe and diarize audio and video content from YouTube, X, Instagram, and TikTok. Submit transcription jobs and retrieve...](/agentkit/connectors/diarize/) [Bearer Token](/agentkit/connectors/diarize/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fathom.svg)](/agentkit/connectors/fathom/) [Fathom connector](/agentkit/connectors/fathom/) [Connect to Fathom AI meeting assistant. Record, transcribe, and summarize meetings with AI-powered insights](/agentkit/connectors/fathom/) [API Key](/agentkit/connectors/fathom/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fathom.svg)](/agentkit/connectors/fathommcp/) [Fathom MCP connector](/agentkit/connectors/fathommcp/) [Connect to Fathom MCP to access AI meeting notes, summaries, transcripts, and recordings from your AI workflows.](/agentkit/connectors/fathommcp/) [OAuth 2.1/DCR](/agentkit/connectors/fathommcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/fireflies.svg)](/agentkit/connectors/firefliesmcp/) [Fireflies MCP connector](/agentkit/connectors/firefliesmcp/) [Connect to Fireflies MCP. Search meeting transcripts, fetch recordings, manage channels, create soundbites, and retrieve analytics from your AI workflows.](/agentkit/connectors/firefliesmcp/) [OAuth 2.1/DCR](/agentkit/connectors/firefliesmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gong.svg)](/agentkit/connectors/gong/) [Gong connector](/agentkit/connectors/gong/) [Connect with Gong to sync calls, transcripts, insights, coaching and CRM activity](/agentkit/connectors/gong/) [OAuth 2.0](/agentkit/connectors/gong/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/gong.svg)](/agentkit/connectors/gongmcp/) [Gong MCP connector](/agentkit/connectors/gongmcp/) [Connect with Gong MCP to access calls, transcripts, insights, coaching, and sales engagement data via the Model Context Protocol](/agentkit/connectors/gongmcp/) [OAuth2.1](/agentkit/connectors/gongmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/grain.svg)](/agentkit/connectors/grainmcp/) [Grain MCP connector](/agentkit/connectors/grainmcp/) [Grain is a meeting recording and intelligence platform. Use this connector to search and retrieve meeting recordings, transcripts, notes, action items...](/agentkit/connectors/grainmcp/) [OAuth 2.1/DCR](/agentkit/connectors/grainmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/granola.svg)](/agentkit/connectors/granola/) [Granola connector](/agentkit/connectors/granola/) [Connect to Granola to access AI-generated meeting notes, summaries, transcripts, and attendee data from your workspace. Granola automatically records and...](/agentkit/connectors/granola/) [Bearer Token](/agentkit/connectors/granola/) [![](https://cdn.scalekit.cloud/sk-connect/assets/provider-icons/granola.svg)](/agentkit/connectors/granolamcp/) [Granola MCP connector](/agentkit/connectors/granolamcp/) [Connect to Granola MCP using OAuth 2.1 with MCP discovery and dynamic client registration.](/agentkit/connectors/granolamcp/) [OAuth 2.1/DCR](/agentkit/connectors/granolamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/happyscribe.svg)](/agentkit/connectors/happyscribemcp/) [HappyScribe connector](/agentkit/connectors/happyscribemcp/) [HappyScribe is an AI-powered transcription and translation service. Connect your HappyScribe account to search transcripts, generate meeting summaries...](/agentkit/connectors/happyscribemcp/) [OAuth2.1/DCR](/agentkit/connectors/happyscribemcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/jiminny.svg)](/agentkit/connectors/jiminny/) [Jiminny connector](/agentkit/connectors/jiminny/) [Connect with Jiminny to access call recordings, transcripts, coaching insights, and conversation intelligence data.](/agentkit/connectors/jiminny/) [Bearer Token](/agentkit/connectors/jiminny/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/lilt.svg)](/agentkit/connectors/liltmcp/) [LILT MCP connector](/agentkit/connectors/liltmcp/) [LILT is an enterprise translation platform that combines AI speed with human expertise to deliver accurate, domain-specific translations at scale. This...](/agentkit/connectors/liltmcp/) [OAuth 2.1/DCR](/agentkit/connectors/liltmcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/otterai.svg)](/agentkit/connectors/otteraimcp/) [OtterAI MCP connector](/agentkit/connectors/otteraimcp/) [Connect to OtterAI MCP. Search meeting recordings, fetch full transcripts, and retrieve user account info from your AI workflows.](/agentkit/connectors/otteraimcp/) [OAuth 2.1/DCR](/agentkit/connectors/otteraimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/readai.svg)](/agentkit/connectors/readaimcp/) [Read AI MCP connector](/agentkit/connectors/readaimcp/) [Connect to Read AI to access your meeting intelligence — transcripts, summaries, action items, and insights from meetings, emails, and chats. Retrieve...](/agentkit/connectors/readaimcp/) [OAuth2.1/DCR](/agentkit/connectors/readaimcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/supadata.svg)](/agentkit/connectors/supadatamcp/) [Supadata MCP connector](/agentkit/connectors/supadatamcp/) [Connect with Supadata MCP to extract transcripts, metadata, and structured content from YouTube, social media, and the web using AI.](/agentkit/connectors/supadatamcp/) [OAuth 2.1/DCR](/agentkit/connectors/supadatamcp/) [![](https://cdn.scalekit.com/sk-connect/assets/provider-icons/tactiq.svg)](/agentkit/connectors/tactiqmcp/) [Tactiq MCP connector](/agentkit/connectors/tactiqmcp/) [Tactiq captures and transcribes meetings in real time, turning conversations into AI-generated notes, summaries, and action items.](/agentkit/connectors/tactiqmcp/) [OAuth2.1/DCR](/agentkit/connectors/tactiqmcp/) No connectors or tools match your search. --- # DOCUMENT BOUNDARY --- # Activepieces MCP connector > Connect to Activepieces MCP to trigger and manage no-code automation flows directly from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'activepiecesmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Activepieces MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'activepiecesmcp_ap_change_flow_status', 25 toolInput: { flowId: 'YOUR_FLOWID', status: 'YOUR_STATUS' }, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "activepiecesmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Activepieces MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={"flowId":"YOUR_FLOWID","status":"YOUR_STATUS"}, 27 tool_name="activepiecesmcp_ap_change_flow_status", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Branch ap add** — Add a conditional branch to a router step * **Step ap add, ap test** — Add a new step to a flow * **Flow ap build, ap duplicate, ap rename** — Create a NEW flow from scratch in one call: trigger + steps * **Status ap change flow** — Enable or disable a published flow * **Create ap** — Create a new flow in Activepieces * **Delete ap** — Delete a branch from a router step ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Adobe Marketing Agent MCP connector > Connect to Adobe Marketing Cloud. Manage campaigns, analytics, and journeys using a natural-language AI assistant. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Adobe Marketing Agent MCP credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'adobemarketingagentmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Adobe Marketing Agent MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'adobemarketingagentmcp_core-context-management-widget', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "adobemarketingagentmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Adobe Marketing Agent MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="adobemarketingagentmcp_core-context-management-widget", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Preferences core-user** — Read or clear the user’s persisted preferences including sandbox, dataview, org, and region settings * **Dataview core-switch sandbox, core-set** — Update the active sandbox and/or dataview for the session in a single call * **Org core-switch** — Switch to a different Adobe organization by exchanging the current IMS token * **Sandbox core-set** — Set the active Adobe Experience Platform sandbox for the current session * **Feedback core-provide** — Submit user feedback about the AI assistant experience; automatically classifies sentiment and calls the feedback API * **Decision core-plan completion** — Submit the user’s approval or rejection for a pending plan before it is executed ## Common workflows [Section titled “Common workflows”](#common-workflows) ### Send a query to the Adobe Marketing AI assistant Use `adobemarketingagentmcp_adobe-marketing-agent-mcp-widget` to ask questions about your campaigns, audiences, journeys, and Analytics data in plain English. * Node.js ```typescript 1 const result = await actions.executeTool({ 2 connectionName: 'adobemarketingagentmcp', 3 identifier: 'user_123', 4 toolName: 'adobemarketingagentmcp_adobe-marketing-agent-mcp-widget', 5 toolInput: { 6 query: 'What are my top performing audience segments this month?', 7 }, 8 }); 9 console.log(result); ``` * Python ```python 1 result = actions.execute_tool( 2 connection_name="adobemarketingagentmcp", 3 identifier="user_123", 4 tool_name="adobemarketingagentmcp_adobe-marketing-agent-mcp-widget", 5 tool_input={ 6 "query": "What are my top performing audience segments this month?", 7 }, 8 ) 9 print(result) ``` ### Switch sandbox and dataview Use `adobemarketingagentmcp_core-switch_sandbox_dataview` to update the active Adobe Experience Platform sandbox and Customer Journey Analytics dataview in a single call. * Node.js ```typescript 1 const result = await actions.executeTool({ 2 connectionName: 'adobemarketingagentmcp', 3 identifier: 'user_123', 4 toolName: 'adobemarketingagentmcp_core-switch_sandbox_dataview', 5 toolInput: { 6 sandboxName: 'prod', 7 dataviewName: 'My Analytics View', 8 }, 9 }); 10 console.log(result); ``` * Python ```python 1 result = actions.execute_tool( 2 connection_name="adobemarketingagentmcp", 3 identifier="user_123", 4 tool_name="adobemarketingagentmcp_core-switch_sandbox_dataview", 5 tool_input={ 6 "sandboxName": "prod", 7 "dataviewName": "My Analytics View", 8 }, 9 ) 10 print(result) ``` ### Poll an async task Some Adobe Marketing operations run asynchronously. Submit a query with `execution_mode: "async"`, then poll with `adobemarketingagentmcp_core-get_task` until the task completes. * Node.js ```typescript 1 // Step 1 — submit async query 2 const submitted = await actions.executeTool({ 3 connectionName: 'adobemarketingagentmcp', 4 identifier: 'user_123', 5 toolName: 'adobemarketingagentmcp_adobe-marketing-agent-mcp-widget', 6 toolInput: { 7 query: 'Generate a full audience overlap report', 8 execution_mode: 'async', 9 }, 10 }); 11 const taskId = submitted.data?.task_id; 12 13 // Step 2 — poll until complete 14 let cursor = 0; 15 while (true) { 16 const status = await actions.executeTool({ 17 connectionName: 'adobemarketingagentmcp', 18 identifier: 'user_123', 19 toolName: 'adobemarketingagentmcp_core-get_task', 20 toolInput: { task_id: taskId, cursor }, 21 }); 22 cursor = status.data?.cursor ?? cursor; 23 if (status.data?.status === 'completed') { 24 console.log(status.data.result); 25 break; 26 } 27 await new Promise(r => setTimeout(r, 2000)); 28 } ``` * Python ```python 1 import time 2 3 # Step 1 — submit async query 4 submitted = actions.execute_tool( 5 connection_name="adobemarketingagentmcp", 6 identifier="user_123", 7 tool_name="adobemarketingagentmcp_adobe-marketing-agent-mcp-widget", 8 tool_input={ 9 "query": "Generate a full audience overlap report", 10 "execution_mode": "async", 11 }, 12 ) 13 task_id = submitted.data.get("task_id") 14 15 # Step 2 — poll until complete 16 cursor = 0 17 while True: 18 status = actions.execute_tool( 19 connection_name="adobemarketingagentmcp", 20 identifier="user_123", 21 tool_name="adobemarketingagentmcp_core-get_task", 22 tool_input={"task_id": task_id, "cursor": cursor}, 23 ) 24 cursor = status.data.get("cursor", cursor) 25 if status.data.get("status") == "completed": 26 print(status.data.get("result")) 27 break 28 time.sleep(2) ``` ### Read and clear user preferences User preferences (sandbox, dataview, org, region) persist for 90 days. Use `adobemarketingagentmcp_core-user_preferences` to read or clear them. * Node.js ```typescript 1 // Read current preferences 2 const prefs = await actions.executeTool({ 3 connectionName: 'adobemarketingagentmcp', 4 identifier: 'user_123', 5 toolName: 'adobemarketingagentmcp_core-user_preferences', 6 toolInput: { action: 'get' }, 7 }); 8 console.log(prefs.data); 9 10 // Clear all preferences 11 await actions.executeTool({ 12 connectionName: 'adobemarketingagentmcp', 13 identifier: 'user_123', 14 toolName: 'adobemarketingagentmcp_core-user_preferences', 15 toolInput: { action: 'clear' }, 16 }); ``` * Python ```python 1 # Read current preferences 2 prefs = actions.execute_tool( 3 connection_name="adobemarketingagentmcp", 4 identifier="user_123", 5 tool_name="adobemarketingagentmcp_core-user_preferences", 6 tool_input={"action": "get"}, 7 ) 8 print(prefs.data) 9 10 # Clear all preferences 11 actions.execute_tool( 12 connection_name="adobemarketingagentmcp", 13 identifier="user_123", 14 tool_name="adobemarketingagentmcp_core-user_preferences", 15 tool_input={"action": "clear"}, 16 ) ``` ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # AdvancedMD connector > AdvancedMD is a cloud-based medical practice management and electronic health record (EHR) platform. This connector uses the SMART on FHIR authorization... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your AdvancedMD credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Read clinical records** — retrieve a Patient, Practitioner, Organization, Encounter, Condition, Observation, AllergyIntolerance, Immunization, MedicationRequest, DiagnosticReport, Procedure, or Appointment by its FHIR logical ID * **Search clinical records** — find any supported FHIR resource using parameters like patient, clinical status, category, date, and code * **Create clinical records** — add new records for any of the twelve supported FHIR resource types * **Update clinical records** — modify an existing FHIR resource by its logical ID * **Delete clinical records** — remove a FHIR resource by its logical ID * **Retrieve everything for a patient** — invoke the `$everything` operation on a Patient to pull all associated clinical resources in a single Bundle ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Adzviser MCP connector > Connect to Adzviser MCP to query real-time marketing analytics across 46+ platforms - Google Ads, Facebook Ads, GA4, TikTok, LinkedIn, and more - from a... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Adzviser MCP credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'adzvisermcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Adzviser MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'adzvisermcp_list_metrics_and_breakdowns_activecampaign', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "adzvisermcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Adzviser MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="adzvisermcp_list_metrics_and_breakdowns_activecampaign", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Data retrieve reporting** — Retrieve real-time reporting data from marketing channels like Google Ads, Facebook Ads and Google Analytics * **List workspace, metrics fb page, metrics and breakdowns zoho** — Retrieve a list of workspaces that have been created by the user and their data sources, such as Google Ads, Facebook Ads accounts connected with each ## Common workflows [Section titled “Common workflows”](#common-workflows) ### List workspaces Use `adzvisermcp_list_workspace` to retrieve the workspaces the user has configured, along with their connected ad platform accounts. * Node.js ```typescript 1 const result = await actions.executeTool({ 2 connectionName: 'adzvisermcp', 3 identifier: 'user_123', 4 toolName: 'adzvisermcp_list_workspace', 5 toolInput: {}, 6 }); 7 console.log(result); ``` * Python ```python 1 result = actions.execute_tool( 2 connection_name="adzvisermcp", 3 identifier="user_123", 4 tool_name="adzvisermcp_list_workspace", 5 tool_input={}, 6 ) 7 print(result) ``` ### Discover available metrics for a platform Before querying data, call a `list_metrics_and_breakdowns_*` tool to discover valid metric and breakdown names for your target platform. * Node.js ```typescript 1 // Discover Google Ads metrics and breakdowns 2 const fields = await actions.executeTool({ 3 connectionName: 'adzvisermcp', 4 identifier: 'user_123', 5 toolName: 'adzvisermcp_list_metrics_and_breakdowns_google_ads', 6 toolInput: {}, 7 }); 8 console.log(fields); ``` * Python ```python 1 # Discover Google Ads metrics and breakdowns 2 fields = actions.execute_tool( 3 connection_name="adzvisermcp", 4 identifier="user_123", 5 tool_name="adzvisermcp_list_metrics_and_breakdowns_google_ads", 6 tool_input={}, 7 ) 8 print(fields) ``` ### Retrieve reporting data across platforms Use `adzvisermcp_retrieve_reporting_data` to pull structured analytics from one or more connected platforms. Pass an `adzviser_request` object to specify metrics, breakdowns, date ranges, and filters. Most use cases work without this parameter — Adzviser auto-fetches data from all connected accounts. * Node.js ```typescript 1 const report = await actions.executeTool({ 2 connectionName: 'adzvisermcp', 3 identifier: 'user_123', 4 toolName: 'adzvisermcp_retrieve_reporting_data', 5 toolInput: { 6 adzviser_request: { 7 google_ads_request: { 8 metrics: ['Clicks', 'Impressions', 'Cost'], 9 breakdowns: ['Campaign Name'], 10 date_ranges: [{ start_date: '2024-01-01', end_date: '2024-01-31' }], 11 }, 12 }, 13 }, 14 }); 15 console.log(report); ``` * Python ```python 1 report = actions.execute_tool( 2 connection_name="adzvisermcp", 3 identifier="user_123", 4 tool_name="adzvisermcp_retrieve_reporting_data", 5 tool_input={ 6 "adzviser_request": { 7 "google_ads_request": { 8 "metrics": ["Clicks", "Impressions", "Cost"], 9 "breakdowns": ["Campaign Name"], 10 "date_ranges": [{"start_date": "2024-01-01", "end_date": "2024-01-31"}], 11 }, 12 }, 13 }, 14 ) 15 print(report) ``` ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Affinda MCP connector > AI-powered document processing platform that extracts, validates, and integrates structured data from invoices, resumes, contracts, and custom document... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'affindamcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Affinda MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'affindamcp_list_organizations', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "affindamcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Affinda MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="affindamcp_list_organizations", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Processing wait for document** — Block until every document in a workspace has finished processing * **Update workspace, validation rule, organization** — Update one or more settings on an existing workspace * **Connection test** — Verify a service connection’s credentials are still valid * **Secret set integration** — Create or update a secret on an integration * **Run integration** — Execute an integration against one document as a test run * **Version revert integration, deploy integration** — Roll an integration back to a previous version and redeploy it ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Affinity connector > Connect to Affinity relationship intelligence CRM to manage deal flow, relationships, pipeline opportunities, and network connections for private capital... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'affinity' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'affinity_list_lists', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "affinity" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="affinity_list_lists", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Create note, opportunity** — Create a note on a person, organization, or opportunity in Affinity * **Get opportunity, relationship strength, organization** — Retrieve full details of a deal or opportunity in Affinity including current stage, owner, associated persons and organizations, custom field values, and list membership * **List opportunities, lists, notes** — List pipeline opportunities in Affinity with optional filters by list ID, owner, or stage * **Search persons, organizations** — Search for people in the Affinity network by name, email, or relationship strength * **Update opportunity** — Update an existing deal or opportunity in Affinity ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Agency Analytics MCP connector > Agency Analytics is a marketing reporting platform that enables digital agencies to monitor SEO, PPC, social media, and other channel performance in... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'agencyanalyticsmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Agency Analytics MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'agencyanalyticsmcp_fetch_web', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "agencyanalyticsmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Agency Analytics MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="agencyanalyticsmcp_fetch_web", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Search web, users, clients** — Search the live web and return a compact keyword-research result set: organic results (position, title, link, domain, snippet), related searches, People Also Ask questions, and the answer box when present * **Read knowledge base, client traffic, client reviews** — Search the AgencyAnalytics knowledge base for how-to articles and platform documentation * **Fetch web** — Fetch a single public web page or document by URL and return its readable text * **Create mcp feedback** — Record user feedback explicitly directed at the AgencyAnalytics MCP server experience — its tools, ergonomics, or quality of results * **Clients browse** — Browse or enumerate clients * **Reports browse client** — List all reports for a client/campaign ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Agentmail MCP connector > Connect to Agentmail MCP. Manage inboxes, send and receive email, handle drafts, threads, and attachments from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'agentmailmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Agentmail MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'agentmailmcp_list_inboxes', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "agentmailmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Agentmail MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="agentmailmcp_list_inboxes", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update message, draft** — Update a message’s labels by adding or removing label values * **Send message, draft** — Send a new email message from an inbox to one or more recipients * **Message reply to, forward** — Reply to a specific message, optionally replying to all recipients * **List threads, inboxes, drafts** — List message threads in an inbox with optional label filtering and pagination * **Get thread, inbox, draft** — Retrieve a message thread by ID, including all messages in the conversation * **Delete inbox, draft** — Permanently delete an inbox and all its associated messages ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Ahrefs MCP connector > Connect to Ahrefs MCP to access SEO data including backlinks, keyword research, site audits, rank tracking, and web analytics directly from your AI... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'ahrefsmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Ahrefs MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'ahrefsmcp_management_brand_radar_reports', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "ahrefsmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Ahrefs MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="ahrefsmcp_management_brand_radar_reports", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Analyze backlinks** — retrieve backlink profiles, referring domains, anchors, and broken links for any URL or domain * **Research keywords** — get keyword ideas, search volume, difficulty scores, SERP overviews, and ranking history * **Explore site data** — fetch organic and paid traffic estimates, top pages, and outlinks for any domain * **Track rankings** — monitor keyword positions across countries and devices over time * **Audit sites** — run crawls to surface broken pages, redirect chains, and on-page SEO issues * **Analyze web analytics** — retrieve traffic stats, top pages, UTM breakdowns, and traffic sources for Web Analytics projects ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Airbyte MCP connector > Connect to Airbyte's MCP server to manage data pipelines, sources, destinations, and connections for your data integration workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'airbytemcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Airbyte MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'airbytemcp_check_enrollment_status', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "airbytemcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Airbyte MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="airbytemcp_check_enrollment_status", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Workspace use** — Switch the active workspace for the session * **Organization use** — Switch the active organization for the session * **Flow start credential** — Start a browser-based credential flow to connect a data source * **Search skills** — Search available skill documentation entries by a basic keyword * **Read skill docs** — Read usage documentation for a skill * **List workspaces, skills, organizations** — List all workspaces in your organization ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Airops MCP connector > Connect to AirOps MCP. Manage brand kits, run AI-powered analytics, track AEO citations, and automate content workflows from your AI agents. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Airops MCP credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. 4. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'airopsmcp' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'airopsmcp_list_aeo_page_content_updates', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "airopsmcp" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="airopsmcp_list_aeo_page_content_updates", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Grid write** — Create or update rows in a grid table * **Update brand kit, track aeo page content** — Update a Brand Kit’s base fields * **Edits suggest brand kit** — Suggest edits to a Brand Kit’s fields without applying them * **Search knowledge base** — Search a Knowledge Base for relevant content using semantic similarity * **Run grid rows** — Trigger execution of one or more grid rows * **Read grid** — Read rows from a grid table ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Airparser MCP connector > AI-powered document parser that extracts structured data from PDFs, emails, and other documents. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'airparsermcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Airparser MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'airparsermcp_get_extraction_schema_format_guide', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "airparsermcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Airparser MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="airparsermcp_get_extraction_schema_format_guide", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Sync upload document** — Upload one document to an Airparser inbox and wait for the parsed result * **Update fields meta, extraction schema from json schema, extraction schema** — Enable or disable per-document output metadata fields for an Airparser inbox * **Code test postprocessing, save postprocessing** — Run Airparser post-processing Python code against an existing parsed document without saving it * **Enabled set postprocessing** — Enable or disable the saved Airparser post-processing step for an inbox * **List inboxes, documents** — List active Airparser inboxes available to the authenticated user * **Get postprocessing runtime rules, postprocessing, inbox** — Get the runtime constraints and allowed imports for Airparser post-processing Python code ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Airtable connector > Connect to Airtable. Manage databases, tables, records, and collaborate on structured data 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Airtable credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'airtable' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Airtable:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'airtable_list_bases', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "airtable" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Airtable:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="airtable_list_bases", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update table, records, field** — Update a table’s name or description in an Airtable base * **Webhook refresh** — Refresh an Airtable webhook to extend its expiration time * **List webhooks, webhook payloads, records** — List all webhooks configured for an Airtable base * **Get record, base schema** — Retrieve a single record from an Airtable table by its record ID * **Delete webhook, records, record** — Delete an Airtable webhook * **Create webhook, table, records** — Create a new webhook for an Airtable base to receive real-time notifications when data changes ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Airtable MCP connector > Connect to Airtable MCP. Manage bases, tables, records, views, fields, and automations from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'airtablemcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Airtable MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'airtablemcp_list_bases', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "airtablemcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Airtable MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="airtablemcp_list_bases", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update table, records for table, field** — Updates an existing table’s name and/or description in an Airtable base * **Search records, bases** — Searches for records in a table using a free-text query with fuzzy matching and token-based search * **Interface publish** — Publishes an interface, promoting each page’s working draft to the live version that end users see * **Ping records** — Pings the Airtable MCP server to check if it is running and reachable * **List workspaces, tables for base, records for table** — Lists all Airtable workspaces the current user has access to, along with their permission level in each * **Get table schema, record for page** — Gets detailed schema information for specified tables and fields in an Airtable base, returning the field ID, type, and configuration for each specified field ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # AlphaXiv MCP connector > Connect to AlphaXiv MCP to search and retrieve arXiv research papers, abstracts, authors, and citations from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'alphaxivmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize AlphaXiv MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'alphaxivmcp_get_paper_content', 25 toolInput: { url: 'https://example.com/url' }, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "alphaxivmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize AlphaXiv MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={"url":"https://example.com/url"}, 27 tool_name="alphaxivmcp_get_paper_content", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Read files from github repository** — Reads the contents of a file or directory from the paper’s codebase repository * **Get paper content** — Get the content of an arXiv/alphaXiv paper as text * **Papers discover** — Discovers and ranks multiple candidate papers for a research topic * **Queries answer pdf** — Returns raw filtered page content from one PDF as XML ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Amplitude Analytics connector > Connect to Amplitude's analytics REST APIs: event segmentation, funnels, cohorts, taxonomy, chart annotations, session replay, export, releases, streaming... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Amplitude Analytics credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Category bulk assign annotation** — Assign an existing annotation category to multiple annotations at once * **Create annotation, annotation category, dsar request** — Create a chart annotation marking a single date or a date range, either globally visible on all charts or scoped to one chart * **Delete annotation, annotation category, event category** — Permanently delete a chart annotation from Amplitude * **Events export** — Export raw event data uploaded to Amplitude within a date range as a zip archive of NDJSON files * **Get annotation, annotation category, cohort membership file** — Retrieve a single chart annotation by its ID * **List annotation categories, annotations, cohorts** — List all chart annotation categories in the Amplitude project, or filter to a single category by name ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Amplitude Experiment Management connector > Manage Amplitude Experiment feature flags, experiments, mutex groups, holdouts, and deployments. Separate connector from Experiment Evaluation (real-time... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Amplitude Experiment Management credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. 4. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'amplitudeexperimentmanagement' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'amplitudeexperimentmanagement_list_all_versions', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "amplitudeexperimentmanagement" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="amplitudeexperimentmanagement_list_all_versions", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Cohorts add experiment variant, add flag variant** — Add specific cohorts to this experiment variant’s targeting inclusions * **Users add experiment variant, add flag variant, remove all experiment variant** — Force-bucket specific users or devices into this experiment variant — identified by user ID, device ID, or an email-style identifier — bypassing the experiment’s normal allocation * **Delete bulk** — Remove a specific set of cohorts (by ID) from an experiment variant’s targeting, leaving other included cohorts untouched * **Create deployment, experiment, experiment deployment** — Create a new deployment in a project * **Get experiment, experiment variant, experiment variant cohorts** — Get complete details for a single Amplitude experiment by its ID * **List all versions, deployments, experiment deployments** — List version history across ALL flags and experiments the API key can access, in one global, paginated feed — distinct from amplitudeexperimentmanagement\_list\_flag\_versions and amplitudeexperimentmanagement\_list\_experiment\_versions, which return the version history for one specific flag or experiment and do NOT support start/end/limit/cursor pagination ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Anakin MCP connector > Anakin is an AI platform and marketplace that lets you build, deploy, and access a wide range of AI tools and automated workflows. This MCP connector... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'anakinmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Anakin MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'anakinmcp_agentic_search', 25 toolInput: { prompt: 'YOUR_PROMPT' }, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "anakinmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Anakin MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={"prompt":"YOUR_PROMPT"}, 27 tool_name="anakinmcp_agentic_search", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Read wire** — Run a Wire READ action — one whose type is “read” (it EXTRACTS data and does not change state on the target site): search listings, fetch a category’s products, get a product’s price/specs/reviews, read a profile, pull dashboard metrics * **Identities wire** — List your saved Wire identities and their credentials * **Discover wire** — Find Wire actions for a task from a natural-language intent * **Catalog wire** — Browse the Wire catalog * **Search agentic** — Run an AI web search and return result URLs, titles, and snippets * **Scrape records** — Fetch a single URL and return clean markdown by default ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Anchor Browser MCP connector > Connect to Anchor Browser MCP to run cloud browser automation, control live browser sessions, extract web data, and let AI agents browse and act on the... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'anchorbrowsermcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Anchor Browser MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'anchorbrowsermcp_anchor_tab_list', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "anchorbrowsermcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Anchor Browser MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="anchorbrowsermcp_anchor_tab_list", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **For anchor wait** — Pause the automation until a specified text appears on the page, a specified text disappears from the page, or a given number of seconds elapses * **Type anchor** — Type text into an editable element in the cloud browser page * **Screenshot anchor take** — Take a screenshot of the current browser page or a specific element * **Select anchor tab** — Switch the active browser tab to the tab at the given zero-based index * **New anchor tab** — Open a new browser tab in the cloud session, optionally navigating it to a specified URL * **List anchor tab** — List all currently open tabs in the cloud browser session, returning their indices and titles or URLs ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Apify MCP connector > Connect to Apify MCP to run web scraping, browser automation, and data extraction Actors directly from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Apify MCP credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. 4. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'apifymcp' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'apifymcp_search_actors', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "apifymcp" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="apifymcp_search_actors", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Get key value store record, dataset items, actor run** — Retrieve a record (JSON, text, or binary) from a key-value store by its key * **Run abort actor** — Abort an Actor run that is currently starting or running * **Fetch actor details, apify docs** — Get detailed information about an Actor by its ID or full name (format: ‘username/name’, e.g * **Search actors, apify docs** — Search the Apify Store to FIND and DISCOVER what scraping tools/Actors exist for specific platforms or use cases * **Actor call** — Call any Actor from the Apify Store * **Browser rag web** — Web browser for AI agents and RAG pipelines ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Apollo connector > Connect to Apollo.io to search and enrich B2B contacts and accounts, manage CRM contacts, and automate outreach sequences. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Apollo credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'apollo' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Apollo:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'apollo_list_sequences', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "apollo" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Apollo:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="apollo_list_sequences", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Find and enrich people** — Search Apollo’s contact and people databases, then enrich records with verified emails, phone numbers, and firmographic data * **Manage accounts and organizations** — Search, enrich, create, and update company records, including bulk create and bulk enrich operations * **Work with contacts** — Create, update, and retrieve contacts, update contact stages and owners, and run bulk contact operations * **Track deals** — Create, update, list, and retrieve deals (opportunities) and list deal stages * **Handle tasks** — Create, update, complete, skip, search, and list CRM tasks * **Automate sequences** — Create, update, activate, deactivate, and archive email sequences, and add or remove contacts from them * **Send and monitor email** — Draft emails, send them, check send status, pull email stats, and search outreach messages * **Organize with lists and custom fields** — Create and update lists, add or remove records, and manage custom fields * **Pull insights** — Query reports, review API usage, search conversations, news articles, and job postings, and list users and email accounts ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Apollo MCP connector > Connect to Apollo MCP to search B2B contacts, enrich people and organizations, manage CRM records, and enroll prospects in sequences. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'apollomcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Apollo MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'apollomcp_apollo_contacts_search', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "apollomcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Apollo MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="apollomcp_apollo_contacts_search", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Profile apollo users api** — Use the Profile endpoint to get the user’s profile information (name, email, title, id) * **Stats apollo usage** — Retrieve credit usage stats for the authenticated team — credits used, remaining, and reset windows for enrichment/people-search/email-reveal credits * **Update apollo tasks, apollo sequences, apollo contacts** — Edit an existing task in place — change its title, note, priority, due date, assignee, or the message body (subject / body\_text) for email and LinkedIn-step tasks * **Skip apollo tasks** — Skip a single task without performing it * **Show apollo tasks** — Fetch the full detail of a single task by ID, including the action to perform (e.g * **Search apollo tasks, apollo mixed people api, apollo mixed companies** — Search the tasks in your team’s Apollo account ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # AppSignal MCP connector > AppSignal is an application monitoring and performance management platform providing error tracking, performance monitoring, and alerting for Ruby... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'appsignalmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize AppSignal MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'appsignalmcp_get_applications', 25 toolInput: { context: {} }, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "appsignalmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize AppSignal MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={"context":{}}, 27 tool_name="appsignalmcp_get_applications", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update incidents, dashboard visual** — Bulk update AppSignal incidents: change state, severity, assign or unassign team members * **Actions reorder log line** — Reorder log line actions to change their execution order during log ingestion * **Trigger manage, archive** — Create or update an anomaly detection trigger to monitor a metric threshold * **Action manage log line** — Create or update a log line action (trigger, filter, or metrics type) * **Note manage incident** — Create or update a note on an AppSignal incident * **Dashboard manage** — Create or update an AppSignal dashboard (title and description only) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Asana connector > Connect to Asana. Manage tasks, projects, teams, and workflow automation 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Asana credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'asana' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Asana:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'asana_allocations_list', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "asana" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Asana:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="asana_allocations_list", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Get workspace user, workspace membership, webhook** — Get a user’s workspace-level membership details * **User workspace remove, workspace add, team remove** — Remove a user from a workspace or organization in Asana * **List workspace memberships, workspace custom fields, user workspace memberships** — List all members of a workspace * **Update webhook, time tracking entry, team** — Update the filters on an existing webhook * **Delete webhook, time tracking entry, story** — Permanently delete a webhook * **Create webhook, team, task time tracking entry** — Create a webhook to receive event notifications for a resource ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Asana MCP connector > Connect to Asana MCP server to manage tasks, projects, and teams directly from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Asana MCP credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'asanamcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Asana MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'asanamcp_get_me', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "asanamcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Asana MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="asanamcp_get_me", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update tasks** — Modify one or more Asana tasks in a single operation * **Search tasks preview, tasks, objects** — Display interactive search results for Asana tasks matching the given filters, before committing to any action * **Get workspace agents, users, user** — Return a list of all AI Teammate agents configured in the Asana workspace * **Delete task** — Permanently delete an Asana task and all of its dependent subtasks * **Create tasks, task preview, project status update** — Create one or more Asana tasks immediately, without a confirmation step * **Comment add** — Post a comment (discussion entry) to a specific Asana task ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Atlassian Rovo MCP connector > Connect to Atlassian Rovo MCP server to manage Jira issues, Confluence pages, and Compass components directly from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Atlassian Rovo MCP credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'atlassianmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Atlassian Rovo MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'atlassianmcp_fetch', 25 toolInput: { id: 'https://example.com/id' }, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "atlassianmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Atlassian Rovo MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={"id":"https://example.com/id"}, 27 tool_name="atlassianmcp_fetch", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Manage Jira issues** — create, edit, transition, comment on, and link issues; add worklogs * **Search with JQL** — query issues using Jira Query Language with full field and filter support * **Work with Confluence** — create, update, and retrieve pages; add footer and inline comments * **Manage Compass components** — create, get, and search services, libraries, and applications; define custom fields and relationships * **Look up users and resources** — resolve Atlassian account IDs, list accessible cloud sites, and find project metadata * **Fetch Atlassian content** — retrieve any Atlassian object by its ARI or URL (e.g. a Jira issue or Confluence page URL) ## Common workflows [Section titled “Common workflows”](#common-workflows) ### Get your cloud ID Most Atlassian Rovo MCP tools require a `cloudId` — the UUID that identifies your Atlassian cloud site. Call `atlassianmcp_getaccessibleatlassianresources` once to retrieve it, then pass the `id` field value in every subsequent tool call. * Node.js ```typescript 1 // Step 1 — get the cloud ID 2 const resources = await actions.executeTool({ 3 connectionName: 'atlassianmcp', 4 identifier: 'user_123', 5 toolName: 'atlassianmcp_getaccessibleatlassianresources', 6 toolInput: {}, 7 }); 8 const cloudId = resources[0].id; 9 10 // Step 2 — use cloudId in subsequent calls 11 const issue = await actions.executeTool({ 12 connectionName: 'atlassianmcp', 13 identifier: 'user_123', 14 toolName: 'atlassianmcp_getjiraissue', 15 toolInput: { 16 cloudId, 17 issueIdOrKey: 'KAN-1', 18 }, 19 }); 20 console.log(issue); ``` * Python ```python 1 # Step 1 — get the cloud ID 2 resources = actions.execute_tool( 3 connection_name="atlassianmcp", 4 identifier="user_123", 5 tool_name="atlassianmcp_getaccessibleatlassianresources", 6 tool_input={}, 7 ) 8 cloud_id = resources[0]["id"] 9 10 # Step 2 — use cloud_id in subsequent calls 11 issue = actions.execute_tool( 12 connection_name="atlassianmcp", 13 identifier="user_123", 14 tool_name="atlassianmcp_getjiraissue", 15 tool_input={ 16 "cloudId": cloud_id, 17 "issueIdOrKey": "KAN-1", 18 }, 19 ) 20 print(issue) ``` The `atlassianmcp_getaccessibleatlassianresources` response looks like this: ```json 1 [ 2 { 3 "id": "a4c9b3e2-1234-5678-abcd-ef0123456789", 4 "name": "My Company", 5 "url": "https://mycompany.atlassian.net", 6 "scopes": ["read:jira-work", "write:jira-work", "read:confluence-content.all"] 7 } 8 ] ``` Use `id` as the `cloudId` parameter. If the user belongs to multiple Atlassian sites, the list contains one entry per site — pick the one matching the target `url`. ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Attention connector > Connect to Attention for AI insights, conversations, teams, and workflows 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'attention' 12 const identifier = 'user_123' 13 14 // Make your first API call through the proxy 15 const result = await actions.request({ 16 connectionName: connector, 17 identifier, 18 path: '/v1/users/me', 19 method: 'GET', 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "attention" 14 identifier = "user_123" 15 16 # Make your first API call through the proxy 17 result = actions.request( 18 connection_name=connection_name, 19 identifier=identifier, 20 path="/v1/users/me", 21 method="GET", 22 ) 23 print(result) ``` ## Common workflows [Section titled “Common workflows”](#common-workflows) --- # DOCUMENT BOUNDARY --- # Attio connector > Connect to Attio CRM to manage contacts, companies, deals, notes, tasks, and lists with a modern relationship management platform. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Attio credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'attio' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Attio:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'attio_get_current_token_info', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "attio" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Attio:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="attio_get_current_token_info", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **List add to, attribute options, attribute statuses** — Add a record (contact, company, deal, or custom object) to a specific Attio list * **Create attribute, comment, company** — Creates a new attribute on an Attio object or list * **Delete comment, company, deal** — Permanently deletes a comment by its comment\_id * **Get attribute, call recording, call transcript** — Retrieves details of a single attribute on an Attio object or list, including its type, slug, configuration, and metadata * **Query sql** — Executes a SQL query against the Attio workspace data * **Search records** — Search for records in Attio for a given object type (people, companies, deals, or custom objects) using a fuzzy text query ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Attio MCP connector > Connect to Attio MCP. Access and manage CRM records, lists, notes, tasks, emails, and workspace data across people, companies, and deals. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'attiomcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Attio MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'attiomcp_list_comments', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "attiomcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Attio MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="attiomcp_list_comments", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Whoami records** — Returns information about the current user’s identity and workspace membership, including their email, name, workspace member ID, access level, and workspace name * **Record upsert** — Create or update a people, companies, or other record using a matching attribute to find an existing record * **Update task, record, note** — Update an existing task’s deadline, completion status, assignee, or linked record * **Search semantic** — Search all notes in the workspace using semantic similarity to find notes where specific topics were discussed, even if exact keywords are not present * **Run basic report** — Run an aggregate report on records in an object or entries in a list, computing totals, averages, minimums, maximums, or grouped breakdowns * **List workspace teams, workspace members, tasks** — List teams in the Attio workspace, returning each team’s ID, name, description, archived status, creation timestamp, and members ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Axiom MCP connector > Axiom is a cloud-native data analytics and observability platform for ingesting, storing, and querying logs, events, traces, and metrics at scale. The MCP... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'axiommcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Axiom MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'axiommcp_check_monitors', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "axiommcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Axiom MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="axiommcp_check_monitors", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update notifier, monitor, dashboard chart** — Update an existing notifier’s configuration * **Search metrics** — Search for metrics by name or partial name pattern * **Query metrics, dataset** — Query OTel metrics from Axiom using MPL (Metrics Processing Language) * **List notifiers, metrics, metric tags** — List all notifiers (notification channels such as email, Slack, PagerDuty) configured in the workspace * **Get saved queries, monitor history, metric tag values** — List all saved APL queries in the Axiom workspace * **Dashboard export** — Export a dashboard configuration as JSON for backup or sharing ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Betterstack MCP connector > Monitor uptime, manage logs, and respond to incidents with Better Stack's observability platform. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'betterstackmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Betterstack MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'betterstackmcp_status_pages', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "betterstackmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Betterstack MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="betterstackmcp_status_pages", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update metric expression, error state, status page report** — Update an existing metric expression * **Pause toggle chart alert** — Pause or unpause a chart alert * **Teams records** — List all available teams in Better Stack Logs * **Pages status** — List all status pages with filtering and pagination options * **Resources status page** — Get resources (monitors/heartbeats) for a specific status page * **Reports status page** — List status reports (incidents/maintenance) for a specific status page ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Google BigQuery connector > BigQuery is Google Cloud’s fully-managed enterprise data warehouse for analytics at scale. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Google BigQuery credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'bigquery' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Google BigQuery:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first API call through the proxy 21 const result = await actions.request({ 22 connectionName: connector, 23 identifier, 24 path: '/bigquery/v2/projects', 25 method: 'GET', 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "bigquery" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Google BigQuery:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first API call through the proxy 25 result = actions.request( 26 connection_name=connection_name, 27 identifier=identifier, 28 path="/bigquery/v2/projects", 29 method="GET", 30 ) 31 print(result) ``` ## Common workflows [Section titled “Common workflows”](#common-workflows) --- # DOCUMENT BOUNDARY --- # BigQuery (Service Account) connector > Connect to Google BigQuery using a GCP service account for server-to-server authentication without user login. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your BigQuery (Service Account) credentials with Scalekit so it handles the token lifecycle. You do this once per environment. ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Query insert** — Submit an asynchronous BigQuery query job * **Job cancel** — Request cancellation of a running BigQuery job * **Run dry, query** — Validate a SQL query and estimate its cost without executing it * **List tables, table data, routines** — List all tables and views in a BigQuery dataset * **Get table, routine, query results** — Retrieve metadata and schema for a specific BigQuery table or view, including column names, types, descriptions, and table properties ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Biomni MCP connector > Connect to Biomni MCP by phylo.bio, an AI biomedical research assistant. Analyze life-sciences data, interpret genomic variants, query curated databases... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'biomnimcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Biomni MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'biomnimcp_list_projects', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "biomnimcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Biomni MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="biomnimcp_list_projects", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update wait for next** — Long-poll for the next batch of progress on the agent’s current reply, returning only newly-added content blocks since the last call * **File upload** — Upload a small text file (VCF, CSV, TSV, JSON, or code) to a project’s drive by passing its content inline as a UTF-8 string * **Workspace switch** — Switch the caller’s active workspace so that subsequent calls (list\_projects, create\_project, task operations) act in the new workspace * **Task start new** — Auto-create a Biomni task in a project and send the first message in a single call, triggering AI agent execution * **Send message** — Send a user message to an existing Biomni task and trigger AI agent execution * **List workspaces, tasks, result files** — List the workspaces (orgs) the caller belongs to and show which one is currently active ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Bio Render MCP connector > Connect to BioRender MCP. Search BioRender's scientific icon and figure template libraries to build publication-ready biological illustrations. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'biorendermcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Bio Render MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'biorendermcp_search-icons', 25 toolInput: { query: 'YOUR_QUERY' }, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "biorendermcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Bio Render MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={"query":"YOUR_QUERY"}, 27 tool_name="biorendermcp_search-icons", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Search-templates records** — Search BioRender’s scientific figure template library * **Search-icons records** — Search BioRender’s scientific icon library by keyword ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Bitbucket connector > Connect to Bitbucket. Manage repositories, pipelines, pull requests, and code collaboration. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Bitbucket credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'bitbucket' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Bitbucket:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'bitbucket_user_emails_list', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "bitbucket" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Bitbucket:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="bitbucket_user_emails_list", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Get commit comment, workspace, merge base** — Returns a specific comment on a commit * **Search workspace** — Searches for code across all repositories in a workspace * **Delete workspace pipeline variable, deploy key, repository permission user** — Deletes a workspace pipeline variable * **Create tag, environment, commit build status** — Creates a new tag in a Bitbucket repository pointing to a specific commit * **Update pull request task, deployment variable, commit build status** — Updates a task on a pull request (e.g * **Unwatch issue** — Stops watching an issue ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Bitly MCP connector > Connect with Bitly MCP for URL shortening, link analytics, and branded links. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'bitlymcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Bitly MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'bitlymcp_get_custom_domains', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "bitlymcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Bitly MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="bitlymcp_get_custom_domains", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Create and manage short links** — shorten URLs, create links with custom back-halves, update link metadata, and delete links * **Create and manage QR codes** — generate QR codes for links, update QR code settings, and retrieve QR code images * **Analyze link performance** — get click summaries, engagement metrics, and breakdowns by city, country, device, referrer, and referring domain * **Analyze QR code scans** — get scan summaries and breakdowns by city, country, device, and browser * **Analyze group-level engagement** — query top links, clicks, scans, and engagement trends across all links in a group * **Manage account structure** — retrieve organizations, groups, custom domains, and user details ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Bitquery MCP connector > Connect to Bitquery MCP. Query on-chain DEX trading data, token prices, OHLCV series, trader profiles, and trending tokens across multiple blockchains... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'bitquerymcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Bitquery MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'bitquerymcp_find_currencies', 25 toolInput: { query: 'YOUR_QUERY' }, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "bitquerymcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Bitquery MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={"query":"YOUR_QUERY"}, 27 tool_name="bitquerymcp_find_currencies", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Tokens trending, find** — Find trending tokens by volume or trade count on a blockchain over a given time window * **Profile trader** — Get a summary profile of a wallet’s recent trading behavior, including tokens traded and volume * **Positions trader** — Retrieve the current token positions held by a trader wallet across blockchains * **Activity trader** — Retrieve a wallet’s trading activity bucketed by time interval to show trading patterns * **Token top traders by, profitable traders by, accumulating traders by** — Find the most active or highest-volume traders for a specific token over a given time window * **Pair top traders by** — Find the top traders for a specific base/quote token pair over a given time window ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Bonsai MCP connector > Connect to Bonsai, the all-in-one business management platform for freelancers and agencies. Manage projects, tasks, CRM contacts, deals, invoices, and... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'bonsaimcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Bonsai MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'bonsaimcp_list_board_groups', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "bonsaimcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Bonsai MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="bonsaimcp_list_board_groups", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update contact, company** — Update an existing CRM contact in Bonsai * **List team members, tasks, projects** — List team members in the user’s current Bonsai company * **Get task** — Fetch a single task from Bonsai by its UUID * **Create time entry, task, project** — Log a time entry in the user’s Bonsai company ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Box connector > Box is a cloud content management platform. Manage files, folders, users, groups, collaborations, tasks, comments, webhooks, search, and more using the... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Box credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'box' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Box:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'box_collections_list', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "box" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Box:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="box_collections_list", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Get file representations, webhook, web link** — Retrieves available representations for a file, such as thumbnails, PDFs, or extracted text * **List webhooks, users, user memberships** — Retrieves all webhooks for the application * **Update webhook, web link, user** — Updates a webhook’s address or triggers * **Delete webhook, web link, user** — Removes a webhook * **Create webhook, web link, user** — Creates a webhook to receive event notifications * **Restore trash folder, trash file** — Restores a folder from the trash ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Box MCP connector > Connect to Box via MCP to manage files, folders, collaborations, users, groups, tasks, comments, and search content directly from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'boxmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Box MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'boxmcp_list_hubs', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "boxmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Box MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="boxmcp_list_hubs", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Hub add items to, ai qa, copy** — Adds files or folders to an existing Box Hub * **Freeform ai extract** — Extracts data from a Box file using a freeform AI prompt * **Fields ai extract structured from** — Extracts structured data from a Box file using AI based on specified field definitions * **Enhanced ai extract structured from fields, ai extract structured from metadata template** — Enhanced version of AI structured extraction from fields * **Template ai extract structured from metadata** — Extracts structured data from a Box file using AI based on an existing metadata template schema * **File ai qa multi, ai qa single, copy** — Asks a question across multiple Box files using Box AI ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Brave Search connector > Connect to Brave Search to perform web, image, video, and news searches with privacy-focused results, plus AI-powered suggestions and spellcheck. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'brave' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'brave_local_place_search', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "brave" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="brave_local_place_search", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Descriptions local** — Fetch AI-generated descriptions for locations using IDs from a Brave web search response * **Summary summarizer** — Fetch the complete AI-generated summary for a summarizer key * **Search web, local place, image** — Search the web using Brave Search’s privacy-focused search engine * **Completions chat** — Get AI-generated answers grounded in real-time Brave Search results using an OpenAI-compatible chat completions interface * **Pois local** — Fetch detailed Point of Interest (POI) data for up to 20 location IDs returned by a Brave web search response * **Enrichments summarizer** — Fetch enrichment data for a Brave AI summary key ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Brevo MCP connector > Connect to Brevo MCP. Manage email and SMS campaigns, transactional emails, contacts, lists, automations, and loyalty programs from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'brevomcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Brevo MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'brevomcp_accounts_get_corporate_invited_users_list', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "brevomcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Brevo MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="brevomcp_accounts_get_corporate_invited_users_list", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Send whatsapp management, whatsapp campaigns, transac templates** — Send a WhatsApp message to one or more contacts * **Get whatsapp management, whatsapp campaigns** — Retrieve a paginated list of individual WhatsApp event records (unaggregated), including event type, contact number, sender number, message ID, timestamp, and contextual fields like body text, media URL, and error reason where applicable * **Create whatsapp management, whatsapp campaigns, webhooks management** — Create a new WhatsApp message template with the specified name, language, category, and body text * **Update whatsapp campaigns, webhooks management, templates** — Update an existing WhatsApp campaign’s name, status, recipients, or scheduled sending time * **Delete whatsapp campaigns, webhooks management, transac templates** — Delete a WhatsApp campaign by its campaign ID * **History webhooks management export webhooks** — Exports webhook event history to CSV format for analysis and reporting ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Bugsnag MCP connector > Connect to Bugsnag MCP. Monitor errors, releases, traces, and span groups across your projects from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'bugsnagmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Bugsnag MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'bugsnagmcp_bugsnag_get_current_project', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "bugsnagmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Bugsnag MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="bugsnagmcp_bugsnag_get_current_project", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update bugsnag** — Update the status of an error (e.g., ignore, snooze, open, or mark as fixed) * **Groupings bugsnag set network endpoint** — Set network endpoint grouping rules for a project * **List bugsnag** — Retrieve available trace attribute fields for filtering * **Get bugsnag** — Retrieve all spans within a specific distributed trace ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Buildkite MCP connector > Connect to Buildkite MCP. Manage CI/CD pipelines, builds, agents, clusters, and test suites from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'buildkitemcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Buildkite MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'buildkitemcp_list_agents', 25 toolInput: { org_slug: 'YOUR_ORG_SLUG' }, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "buildkitemcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Buildkite MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={"org_slug":"YOUR_ORG_SLUG"}, 27 tool_name="buildkitemcp_list_agents", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Organization user token** — Get the organization associated with the user token used for this request * **Update pipeline schedule, pipeline, cluster queue** — Modify an existing pipeline schedule’s cron expression, branch, environment variables, or enabled state * **Job unblock, retry** — Unblock a blocked job in a Buildkite build to allow it to continue execution * **Logs tail** — Show the last N entries from the log file * **Search logs** — Search log entries using regex patterns with optional context lines * **Dispatch resume cluster queue, pause cluster queue** — Resume dispatch on a paused cluster queue, allowing jobs to be dispatched to agents again ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Calendly connector > Connect to Calendly. Access user profile, events, and scheduling workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Calendly credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'calendly' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Calendly:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'calendly_current_user_get', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "calendly" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Calendly:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="calendly_current_user_get", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Delete webhook subscription, data compliance events, data compliance invitees** — Deletes a Calendly webhook subscription, stopping future event notifications * **List event type availability schedules, group relationships, groups** — Returns a list of availability schedules for the specified Calendly event type * **Create invitee no show, organization invitation, share** — Marks a specific invitee as a no-show for a scheduled Calendly event * **Get sample webhook data, organization membership, organization invitation** — Returns a sample webhook payload for the specified event type, useful for testing webhook integrations * **Update event type availability schedules, event type** — Updates the availability schedules (rules) for the specified Calendly event type * **Revoke organization invitation** — Revokes a pending invitation to a Calendly organization ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Calendly MCP connector > Connect to the Calendly MCP server to manage scheduled events, invitees, event types, and availability directly from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Calendly MCP credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'calendlymcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Calendly MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'calendlymcp_event_types_list_event_types', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "calendlymcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Calendly MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="calendlymcp_event_types_list_event_types", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Get users, routing forms** — Use: Fetch profile for a specific user by URI * **Create shares, scheduling links, organizations** — Use: Create a single-use share link for a one-on-one event type with per-link overrides When: User wants a single-use link with any customization (duration, scheduling window, location, or availability) * **List routing forms, organizations** — Use: List routing forms for the org * **Invitation organizations revoke organization** — Use: Revoke a pending organization invitation * **Delete meetings** — Use: Remove a no-show mark from an invitee * **Event meetings cancel** — Use: Cancel a scheduled meeting on behalf of the connected host When: User confirms they want to cancel a specific meeting ## Common workflows [Section titled “Common workflows”](#common-workflows) ### Resolve the connected user first Most Calendly tools need the connected host’s user URI. Call `calendlymcp_users_get_current_user` once at the start of a workflow, then reuse the returned `resource.uri` (and `timezone`) in later calls. * Node.js ```typescript 1 const me = await actions.executeTool({ 2 connectionName: 'calendlymcp', 3 identifier: 'user_123', 4 toolName: 'calendlymcp_users_get_current_user', 5 toolInput: {}, 6 }); 7 const userUri = me.resource.uri; 8 console.log(userUri, me.resource.timezone); ``` * Python ```python 1 me = actions.execute_tool( 2 connection_name="calendlymcp", 3 identifier="user_123", 4 tool_name="calendlymcp_users_get_current_user", 5 tool_input={}, 6 ) 7 user_uri = me["resource"]["uri"] 8 print(user_uri, me["resource"]["timezone"]) ``` ### List upcoming meetings and their invitees Use `calendlymcp_meetings_list_events` to fetch scheduled meetings, then `calendlymcp_meetings_list_event_invitees` to see who is attending a specific meeting. Pass the `user` URI from the previous step and filter by `status` to limit results to active meetings. * Node.js ```typescript 1 // Step 1 — list active meetings for the connected user 2 const events = await actions.executeTool({ 3 connectionName: 'calendlymcp', 4 identifier: 'user_123', 5 toolName: 'calendlymcp_meetings_list_events', 6 toolInput: { 7 user: userUri, 8 status: 'active', 9 count: '20', 10 }, 11 }); 12 const meetingUri = events.collection[0].uri; 13 14 // Step 2 — list the invitees for that meeting 15 const invitees = await actions.executeTool({ 16 connectionName: 'calendlymcp', 17 identifier: 'user_123', 18 toolName: 'calendlymcp_meetings_list_event_invitees', 19 toolInput: { uri: meetingUri }, 20 }); 21 console.log(invitees); ``` * Python ```python 1 # Step 1 — list active meetings for the connected user 2 events = actions.execute_tool( 3 connection_name="calendlymcp", 4 identifier="user_123", 5 tool_name="calendlymcp_meetings_list_events", 6 tool_input={ 7 "user": user_uri, 8 "status": "active", 9 "count": "20", 10 }, 11 ) 12 meeting_uri = events["collection"][0]["uri"] 13 14 # Step 2 — list the invitees for that meeting 15 invitees = actions.execute_tool( 16 connection_name="calendlymcp", 17 identifier="user_123", 18 tool_name="calendlymcp_meetings_list_event_invitees", 19 tool_input={"uri": meeting_uri}, 20 ) 21 print(invitees) ``` ### Book a slot on an event type Find a bookable slot with `calendlymcp_event_types_list_event_type_available_times`, then book it with `calendlymcp_meetings_create_invitee`. Pass the UTC `start_time` from the availability response verbatim — do not rewrite it to a local label. Confirm the slot before booking Always read available times first and pass the returned UTC `start_time` straight into the booking call. Booking without confirming availability can fail or double-book. * Node.js ```typescript 1 // Step 1 — find available times for the event type 2 const slots = await actions.executeTool({ 3 connectionName: 'calendlymcp', 4 identifier: 'user_123', 5 toolName: 'calendlymcp_event_types_list_event_type_available_times', 6 toolInput: { 7 event_type: 'https://api.calendly.com/event_types/EVENT_TYPE_UUID', 8 start_time: '2026-07-01T00:00:00Z', 9 end_time: '2026-07-07T00:00:00Z', 10 }, 11 }); 12 const startTime = slots.collection[0].start_time; 13 14 // Step 2 — book the slot for an invitee 15 const booking = await actions.executeTool({ 16 connectionName: 'calendlymcp', 17 identifier: 'user_123', 18 toolName: 'calendlymcp_meetings_create_invitee', 19 toolInput: { 20 post_invitee_request: { 21 event_type: 'https://api.calendly.com/event_types/EVENT_TYPE_UUID', 22 start_time: startTime, 23 name: 'Jordan Lee', 24 email: 'jordan@example.com', 25 }, 26 }, 27 }); 28 console.log(booking); ``` * Python ```python 1 # Step 1 — find available times for the event type 2 slots = actions.execute_tool( 3 connection_name="calendlymcp", 4 identifier="user_123", 5 tool_name="calendlymcp_event_types_list_event_type_available_times", 6 tool_input={ 7 "event_type": "https://api.calendly.com/event_types/EVENT_TYPE_UUID", 8 "start_time": "2026-07-01T00:00:00Z", 9 "end_time": "2026-07-07T00:00:00Z", 10 }, 11 ) 12 start_time = slots["collection"][0]["start_time"] 13 14 # Step 2 — book the slot for an invitee 15 booking = actions.execute_tool( 16 connection_name="calendlymcp", 17 identifier="user_123", 18 tool_name="calendlymcp_meetings_create_invitee", 19 tool_input={ 20 "post_invitee_request": { 21 "event_type": "https://api.calendly.com/event_types/EVENT_TYPE_UUID", 22 "start_time": start_time, 23 "name": "Jordan Lee", 24 "email": "jordan@example.com", 25 }, 26 }, 27 ) 28 print(booking) ``` ### Share a single-use scheduling link Use `calendlymcp_scheduling_links_create_single_use_scheduling_link` to generate a one-time booking link for an event type, then send the returned `booking_url` to the invitee. Use this when you want the link to follow the event type’s existing settings without overrides. * Node.js ```typescript 1 const link = await actions.executeTool({ 2 connectionName: 'calendlymcp', 3 identifier: 'user_123', 4 toolName: 'calendlymcp_scheduling_links_create_single_use_scheduling_link', 5 toolInput: { 6 create_scheduling_link_request: { 7 owner: 'https://api.calendly.com/event_types/EVENT_TYPE_UUID', 8 owner_type: 'EventType', 9 max_event_count: 1, 10 }, 11 }, 12 }); 13 console.log(link.resource.booking_url); ``` * Python ```python 1 link = actions.execute_tool( 2 connection_name="calendlymcp", 3 identifier="user_123", 4 tool_name="calendlymcp_scheduling_links_create_single_use_scheduling_link", 5 tool_input={ 6 "create_scheduling_link_request": { 7 "owner": "https://api.calendly.com/event_types/EVENT_TYPE_UUID", 8 "owner_type": "EventType", 9 "max_event_count": 1, 10 }, 11 }, 12 ) 13 print(link["resource"]["booking_url"]) ``` ### Cancel a meeting Use `calendlymcp_meetings_cancel_event` with the meeting `uri` from `calendlymcp_meetings_list_events`. Canceling notifies every invitee, so confirm the action with the user first. To reschedule instead, surface the invitee’s `reschedule_url` rather than canceling. * Node.js ```typescript 1 await actions.executeTool({ 2 connectionName: 'calendlymcp', 3 identifier: 'user_123', 4 toolName: 'calendlymcp_meetings_cancel_event', 5 toolInput: { 6 uri: meetingUri, 7 create_scheduled_event_cancellation_request: 'Host unavailable — will follow up to reschedule.', 8 }, 9 }); ``` * Python ```python 1 actions.execute_tool( 2 connection_name="calendlymcp", 3 identifier="user_123", 4 tool_name="calendlymcp_meetings_cancel_event", 5 tool_input={ 6 "uri": meeting_uri, 7 "create_scheduled_event_cancellation_request": "Host unavailable — will follow up to reschedule.", 8 }, 9 ) ``` ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Cal MCP connector > Connect to Cal MCP. Manage bookings, event types, schedules, and availability from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'calmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Cal MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'calmcp_get_bookings', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "calmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Cal MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="calmcp_get_bookings", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update schedule, org membership, me** — Update an existing schedule * **Booking reschedule, confirm, cancel** — Reschedule a booking to a new time * **Absent mark booking** — Mark host or attendees as absent for a past booking * **Get schedules, schedule, org routing forms** — List all schedules for the authenticated user * **Delete schedule, org membership, event type** — Delete a schedule by its numeric ID * **Create schedule, org membership, event type** — Create a new schedule ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Candid MCP connector > Connect to Candid MCP. Search nonprofit organizations, explore philanthropic data, and classify social sector activities using Candid's knowledge base. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'candidmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Candid MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'candidmcp_search_organizations', 25 toolInput: { query: 'YOUR_QUERY' }, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "candidmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Candid MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={"query":"YOUR_QUERY"}, 27 tool_name="candidmcp_search_organizations", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Terms taxonomy** — Classify text using Candid’s Philanthropy Classification System (PCS) taxonomy to get subject and population codes * **Search organizations** — Search Candid’s database for nonprofits and grantmaking organizations by name, mission, location, or type of work * **Resources knowledge** — Search Candid’s knowledge base for articles, blog posts, research reports, and training content about the social and philanthropic sector * **Organizations identify mentioned** — Resolve nonprofit names mentioned in text to Candid profile URLs * **Locations identify** — Detect and resolve geographic names in text to Geonames IDs for use in organization search filters * **Date current** — Get today’s date for use in time-sensitive queries and data requests ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Canva connector > Connect to Canva's Connect API to manage designs, assets, folders, brand templates, comments, autofills, exports, and analytics on the user's behalf via... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Canva credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'canva' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Canva:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'canva_brand_template_list', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "canva" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Canva:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="canva_brand_template_list", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Get user profile, user me, user capabilities** — Get the profile of the Canva user associated with the connected access token * **Create resize, merge, folder** — Starts a new asynchronous job to create a resized copy of a design * **Update folder, asset** — Update a Canva folder’s details using its folder ID * **List folder items, design pages, design** — List the items inside a Canva folder, including each item’s type (design, folder, image, or brand\_template) * **Move folder item** — Move an item (a folder, design, image asset, or brand template) to another folder in Canva * **Delete folder, asset** — Delete a Canva folder using its folder ID ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Carbone.io MCP connector > Connect to Carbone.io MCP. Upload templates, render documents by merging templates with JSON data, convert between 100+ formats, and manage template... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Carbone.io MCP credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. 4. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'carboneiomcp' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'carboneiomcp_get_api_status', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "carboneiomcp" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="carboneiomcp_get_api_status", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Template upload, download** — Upload and store a reusable Carbone template for use with render\_document * **Update template metadata** — Update a stored template’s name, comment, category, tags, or deployment timestamps * **Document render, convert** — Generate a document by merging a Carbone template with JSON data, optionally converting the output format * **List templates, tags, categories** — List stored Carbone templates with optional filtering by category, tag, ID, or search query * **Get capabilities, api status** — Return a summary of all Carbone capabilities including supported formats, features, and usage examples * **Delete template** — Soft-delete a stored Carbone template by its template ID ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Carta MCP connector > Connect to Carta. Manage equity cap tables, fund administration, company accounts, and ownership data for venture-backed companies. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'cartamcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Carta MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'cartamcp_get_current_user', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "cartamcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Carta MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="cartamcp_get_current_user", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Welcome records** — Get a welcome message and orientation guide from Carta MCP * **Static view** — Render an interactive Carta view backed by server-bundled HTML * **Remote view** — Render an interactive Carta view backed by a Module Federation remote * **Context set** — Switch the active firm so subsequent queries use that firm data * **Mutate records** — Execute a write command (POST, PATCH, PUT, DELETE) against Carta * **List contexts, accounts** — List the firms you have access to in Carta Fund Admin ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Catchr MCP connector > Catchr is a data connector platform that syncs marketing and analytics data from ad platforms (Google Ads, Facebook Ads, etc.) to data warehouses and BI... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'catchrmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Catchr MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'catchrmcp_list_all_fields', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "catchrmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Catchr MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="catchrmcp_list_all_fields", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Run api request json, describe** — Execute the Catchr API request in JSON mode for one or multiple accounts * **List sources, platforms, fields for account** — List network authorizations (sources) for the authenticated company, with optional available accounts ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # ChiliPiper MCP connector > Connect to ChiliPiper MCP. Schedule meetings, manage routing rules, track distributions, and automate handoffs from your AI agents. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your ChiliPiper MCP credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. 4. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'chilipipermcp' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'chilipipermcp_concierge-list-routers', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "chilipipermcp" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="chilipipermcp_concierge-list-routers", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Workspace-remove-users records** — Removes one or more users from a specific workspace * **Workspace-remove-users-all records** — Removes all specified users from every workspace they belong to * **Workspace-list records** — Returns a paginated list of workspaces * **Workspace-list-users records** — Returns a paginated list of users in a workspace * **Workspace-add-users records** — Adds one or more users to a workspace * **User-update-licenses records** — Updates the license assignments for a user, replacing the current license set ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Chorus connector > Connect to Chorus.ai to sync calls, transcripts, conversation intelligence, and analytics. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'chorus' 12 const identifier = 'user_123' 13 14 // Make your first API call through the proxy 15 const result = await actions.request({ 16 connectionName: connector, 17 identifier, 18 path: '/v1/users/me', 19 method: 'GET', 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "chorus" 14 identifier = "user_123" 15 16 # Make your first API call through the proxy 17 result = actions.request( 18 connection_name=connection_name, 19 identifier=identifier, 20 path="/v1/users/me", 21 method="GET", 22 ) 23 print(result) ``` ## Common workflows [Section titled “Common workflows”](#common-workflows) --- # DOCUMENT BOUNDARY --- # Circleback MCP connector > Circleback is an AI meeting notes and conversation intelligence platform. The Circleback MCP server provides a standardized interface that allows any... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'circlebackmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Circleback MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'circlebackmcp_finddomains', 25 toolInput: { searchTerms: [] }, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "circlebackmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Circleback MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={"searchTerms":[]}, 27 tool_name="circlebackmcp_finddomains", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Searchtranscripts records** — Search meeting transcripts to find transcript chunks that match a given search term * **Searchsupportarticles records** — Search for support articles about Circleback to find relevant documentation and help content * **Searchmeetings records** — Find meetings that match a given search term or filter * **Searchemails records** — Search the user’s connected email accounts for email threads matching a query * **Searchcalendarevents records** — Get calendar events from the user’s connected calendars * **Searchactionitems records** — Find action items that match a given search term or filter ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Claap MCP connector > Video collaboration platform for recording, sharing, and discussing async video clips — used for meeting recordings, product demos, feedback, and team... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'claapmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Claap MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'claapmcp_list_workspaces', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "claapmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Claap MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="claapmcp_list_workspaces", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Search recording transcripts, emails, deals** — Perform keyword or semantic search on the recording transcript database, with optional filters on the recording metadata * **List workspaces, recording views, emails** — List all Claap workspaces the user has access to * **Get recordings, recording view, recording transcript** — Query the recording metadata database with a set of filters ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Clari Copilot connector > Connect to Clari Copilot for sales call transcripts, analytics, call data, and insights. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'clari-copilot' 12 const identifier = 'user_123' 13 14 // Make your first API call through the proxy 15 const result = await actions.request({ 16 connectionName: connector, 17 identifier, 18 path: '/v1/users/me', 19 method: 'GET', 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "clari-copilot" 14 identifier = "user_123" 15 16 # Make your first API call through the proxy 17 result = actions.request( 18 connection_name=connection_name, 19 identifier=identifier, 20 path="/v1/users/me", 21 method="GET", 22 ) 23 print(result) ``` ## Common workflows [Section titled “Common workflows”](#common-workflows) --- # DOCUMENT BOUNDARY --- # Clarify MCP connector > Connect to Clarify MCP to manage CRM records, leads, campaigns, lists, and analytics directly from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'clarifymcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Clarify MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'clarifymcp_get_campaigns', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "clarifymcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Clarify MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="clarifymcp_get_campaigns", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Manage CRM records** — create, update, delete, and query records across any custom object type * **Manage campaigns** — create, update, delete, and list outreach campaigns with multi-step email sequences * **Find and import leads** — search for leads by criteria and import them into campaigns or lists * **Manage lists and segments** — create, update, delete, and list audience lists for targeting * **Extend the data model** — create, update, and delete custom objects and fields to match your schema * **Analyze and query data** — run analytics queries and retrieve structured data with custom filters ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Clay MCP connector > Clay is a go-to-market (GTM) platform that unifies data sourcing from 150+ providers, AI-powered research agents, and workflow orchestration for sales and... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'claymcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Clay MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'claymcp_get_credits_available', 25 toolInput: { rationale: 'YOUR_RATIONALE' }, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "claymcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Clay MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={"rationale":"YOUR_RATIONALE"}, 27 tool_name="claymcp_get_credits_available", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Event track** — Track an analytics event with optional properties * **Run subroutine no mapping, subroutine direct, subroutine** — Run a custom subroutine on search entities * **Query objects** — Query audience accounts, contacts, or deals using natural language * **List subroutines, find and enrich** — List available custom functions in the workspace * **Get task context, task, subroutine input options** — Retrieve the current state of a task — all entities, enrichment values, and statuses * **Company find and enrich contacts at, find and enrich** — Search for contacts at a company by role, title, name, or department ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Clickhouse MCP connector > Connect to ClickHouse MCP to query, analyze, and manage your ClickHouse databases directly from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'clickhouse' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Clickhouse MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'clickhouse_get_organizations', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "clickhouse" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Clickhouse MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="clickhouse_get_organizations", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Run SELECT queries** — execute read-only SQL queries against any ClickHouse service and retrieve results directly in your agent * **Explore schema** — list databases, tables, and column types to understand your data model before writing queries * **Manage services** — list, inspect, and get full details for ClickHouse Cloud services (clusters) in an organization * **Monitor backups** — list service backups, get backup details, and retrieve the backup schedule and retention config * **Inspect ClickPipes** — list and retrieve data ingestion pipeline status and configuration * **Track costs** — get billing and usage cost data for an organization over a custom date range ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # ClickUp connector > Connect to ClickUp. Manage tasks, projects, workspaces, and team collaboration 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your ClickUp credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'clickup' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize ClickUp:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'clickup_user_get', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "clickup" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize ClickUp:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="clickup_user_get", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Manage tasks** — create, update, delete, and search tasks; set priorities, due dates, assignees, and statuses * **Manage lists** — create, update, and delete lists in folders or as folderless lists; get members * **Manage folders** — create, update, and delete folders; list all folders in a space * **Manage spaces** — create, update, and delete spaces; manage space tags and views * **Manage comments** — add, update, and delete comments on tasks and lists * **Manage goals** — create, update, delete, and list goals and their key results * **Track time** — list and create time entries for tasks * **Manage checklists** — create task checklists and checklist items * **Manage webhooks** — create, update, delete, and list workspace webhooks * **Access workspace data** — get user info, list workspaces, spaces, and views ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Close connector > Connect to Close CRM. Manage leads, contacts, opportunities, tasks, activities, and sales workflows 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Close credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'close' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Close:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'close_activities_list', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "close" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Close:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="close_activities_list", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **List webhooks, users, tasks** — List all webhook subscriptions in Close * **Update webhook, task, sms** — Update a webhook subscription’s URL or event subscriptions * **Get webhook, user, task** — Retrieve a single webhook subscription by ID * **Delete webhook, task, sms** — Delete a webhook subscription from Close * **Create webhook, task, sms** — Create a new webhook subscription to receive Close event notifications * **Merge lead** — Merge two leads into one ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Close MCP connector > Close is a CRM and sales platform. The Close MCP server provides a standardized interface that allows any compatible AI model or agent to access Close CRM... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'closemcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Close MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'closemcp_activity_search', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "closemcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Close MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="closemcp_activity_search", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update task, sms template, pipeline** — Update an existing task * **Search paginate, lead** — Perform a natural language search for leads or contacts * **Call schedule voice agent** — Schedule a voice agent to call a lead’s contact * **Users org** — Return active users (memberships) which are part of the current org * **Info org** — Get information about the Close organization including organization ID, name, and other org-level details * **Get voice agents, voice agent performance report, voice agent overview report** — Return detailed configuration for one or more voice agents ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Cloudflare MCP connector > Connect to Cloudflare MCP to manage your Cloudflare account — execute API calls, search the OpenAPI spec, and interact with Workers, R2, D1, KV, and all... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'cloudfaremcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Cloudflare MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'cloudfaremcp_search', 25 toolInput: { code: 'YOUR_CODE' }, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "cloudfaremcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Cloudflare MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={"code":"YOUR_CODE"}, 27 tool_name="cloudfaremcp_search", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Search records** — Search the Cloudflare OpenAPI spec to discover API endpoints, request parameters, and response schemas * **Execute records** — Execute JavaScript code against the Cloudflare API using the `cloudflare.request()` helper ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Cloudflare connector > Cloudflare is a cloud platform providing DNS management, CDN, security, and networking services. This connector enables automated management of zones, DNS... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'cloudflare' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Cloudflare:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'cloudflare_account_list', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "cloudflare" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Cloudflare:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="cloudflare_account_list", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **List access application, account, dns record** — List all Zero Trust Access applications configured in a Cloudflare account, with optional filtering by name or domain * **Get user** — Retrieve the profile details of the currently authenticated Cloudflare user, including name, email, and account memberships ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Cloudinary MCP connector > Connects AI agents to Cloudinary's asset management platform, enabling upload, search, transformation, and organization of media assets through natural... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'cloudinarymcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Cloudinary MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'cloudinarymcp_get_tx_reference', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "cloudinarymcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Cloudinary MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="cloudinarymcp_get_tx_reference", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Search visual, folders, assets** — Finds images in your asset library based on visual similarity or content Returns a list of resources that are visually similar to a specified image * **Asset upload, transform** — Uploads media assets (images, videos, raw files) to your Cloudinary product environment Uploads media assets (images, videos, raw files) to your Cloudinary product environment * **Folder move** — Renames or moves an entire folder (along with all assets it contains) to a new location Renames or moves an entire folder (along with all assets it contains) to a new location within your Cloudinary media library * **List videos, tags, images** — Get video assets Retrieves a list of video assets * **Get usage details, tx reference, asset details** — Retrieves comprehensive usage metrics and account statistics A report on the status of product environment usage, including storage, credits, bandwidth, requests, number of resources, and add-on usage * **Archive generate** — Creates an archive (ZIP or TGZ file) that contains a set of assets from your product environment ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Cloudpress MCP connector > Cloudpress is a managed WordPress hosting platform built for the AI era. Its MCP server lets AI agents manage sites, domains, DNS, security rules... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'cloudpressmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Cloudpress MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'cloudpressmcp_list_dns_zones', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "cloudpressmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Cloudpress MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="cloudpressmcp_list_dns_zones", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update waf custom rule, shield, rate limit** — Update an existing custom WAF rule for a Cloudpress site * **Rule toggle edge** — Enable or disable an edge rule without deleting it * **Domains suggest** — Get domain name suggestions based on a keyword * **Search domains** — Search for domain names matching a keyword * **Site restart, rename** — Asynchronously restart a Cloudpress site’s container * **Cache purge cdn** — Purge the CDN cache for a site ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Cognee connector > Connect to Cognee, an AI memory engine for agents. Remember data into a knowledge graph, recall it with semantic search, improve stored memory, and forget... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Cognee credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. 4. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'cognee' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'cognee_check_status', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "cognee" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="cognee_check_status", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Status check** — Check the processing status of Cognee datasets’ pipelines * **Create dataset** — Create a new, empty Cognee dataset by name * **Forget records** — Forget stored data in Cognee memory * **Improve records** — Improve stored memory by running Cognee’s enrichment pipeline (the ‘memify’/cognify step) over a dataset * **List dataset data, datasets** — List the individual data items stored in a Cognee dataset, with their UUIDs * **Recall records** — Recall data previously saved to Cognee memory ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # CoinMarketCap MCP connector > Connect to CoinMarketCap MCP. Access real-time crypto quotes, market metrics, technical analysis, trending narratives, and news from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'coinmarketcapmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize CoinMarketCap MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'coinmarketcapmcp_get_crypto_marketcap_technical_analysis', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "coinmarketcapmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize CoinMarketCap MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="coinmarketcapmcp_get_crypto_marketcap_technical_analysis", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Narratives trending crypto** — Get a ranked list of the top trending cryptocurrency narratives, including market cap, trading volume, performance across timeframes, and the top associated tokens * **Search cryptos, crypto info** — Search cryptocurrencies by name, symbol, or slug using fuzzy matching * **Get upcoming macro events, global metrics latest, global crypto derivatives metrics** — Get a list of upcoming macroeconomic events that could impact the crypto market, useful for anticipating price catalysts ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Commonroom MCP connector > Connect to Common Room MCP to manage community members, objects, and feedback data directly from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Commonroom MCP credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'commonroommcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Commonroom MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'commonroommcp_commonroom_get_catalog', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "commonroommcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Commonroom MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="commonroommcp_commonroom_get_catalog", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update commonroom** — Update fields on an existing Common Room object (contact, organization, etc.) by its ID * **Feedback commonroom submit** — Submit feedback on the quality of a query result — use after presenting data to the user * **List commonroom** — List Common Room objects (contacts, organizations, segments, etc.) with optional pagination, filtering, and sorting * **Get commonroom** — Retrieve the catalog of available object types, their properties, and allowed sort fields in Common Room * **Create commonroom** — Create a new object in Common Room — contact, organization, activity, or custom object type ## Common workflows [Section titled “Common workflows”](#common-workflows) ### List community members Use `commonroommcp_commonroom_list_objects` with `objectType` set to `Contact` to retrieve community members with optional filtering and pagination. * Node.js ```typescript 1 const result = await actions.executeTool({ 2 connectionName: 'commonroommcp', 3 identifier: 'user_123', 4 toolName: 'commonroommcp_commonroom_list_objects', 5 toolInput: { 6 objectType: 'Contact', 7 limit: 20, 8 }, 9 }); 10 console.log(result); ``` * Python ```python 1 result = actions.execute_tool( 2 connection_name="commonroommcp", 3 identifier="user_123", 4 tool_name="commonroommcp_commonroom_list_objects", 5 tool_input={ 6 "objectType": "Contact", 7 "limit": 20, 8 }, 9 ) 10 print(result) ``` ### Create a contact Use `commonroommcp_commonroom_create_object` to add a new contact to your Common Room community. * Node.js ```typescript 1 const result = await actions.executeTool({ 2 connectionName: 'commonroommcp', 3 identifier: 'user_123', 4 toolName: 'commonroommcp_commonroom_create_object', 5 toolInput: { 6 objectType: 'Contact', 7 email: 'alex@example.com', 8 fullName: 'Alex Johnson', 9 title: 'Senior Engineer', 10 companyName: 'Example Corp', 11 }, 12 }); 13 console.log(result); ``` * Python ```python 1 result = actions.execute_tool( 2 connection_name="commonroommcp", 3 identifier="user_123", 4 tool_name="commonroommcp_commonroom_create_object", 5 tool_input={ 6 "objectType": "Contact", 7 "email": "alex@example.com", 8 "fullName": "Alex Johnson", 9 "title": "Senior Engineer", 10 "companyName": "Example Corp", 11 }, 12 ) 13 print(result) ``` ### Discover available object types Use `commonroommcp_commonroom_get_catalog` to retrieve the full list of object types, their properties, and allowed sort fields before querying or creating objects. * Node.js ```typescript 1 const catalog = await actions.executeTool({ 2 connectionName: 'commonroommcp', 3 identifier: 'user_123', 4 toolName: 'commonroommcp_commonroom_get_catalog', 5 toolInput: {}, 6 }); 7 console.log(catalog); ``` * Python ```python 1 catalog = actions.execute_tool( 2 connection_name="commonroommcp", 3 identifier="user_123", 4 tool_name="commonroommcp_commonroom_get_catalog", 5 tool_input={}, 6 ) 7 print(catalog) ``` ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Confluence connector > Connect to Confluence. Manage spaces, pages, content, and team collaboration 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Confluence credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'confluence' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Confluence:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'confluence_attachments_list', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "confluence" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Confluence:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="confluence_attachments_list", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Get whiteboard, whiteboard descendants, whiteboard children** — Retrieve a single Confluence whiteboard by its ID * **Delete whiteboard, space role, inline comment** — Delete a Confluence whiteboard by its ID * **Create whiteboard, space role, space** — Create a new whiteboard in a specified Confluence space * **Lookup users bulk** — Look up user details in bulk for a list of account IDs * **Update task, space role, page title** — Update a Confluence task by ID * **List task, space roles, space role assignments** — List all Confluence tasks the current user has permission to view ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Contentful MCP connector > Connect to Contentful MCP. Manage spaces, entries, assets, content types, and taxonomies in your Contentful CMS from AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'contentfulmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Contentful MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'contentfulmcp_get_initial_context', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "contentfulmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Contentful MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="contentfulmcp_get_initial_context", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Asset upload, unpublish, unarchive** — Upload a new asset to Contentful from a URL or file handle * **Update locale, entry, editor interface** — Update an existing locale’s settings such as name, fallback, or API access flags * **Entry unpublish, unarchive, publish** — Unpublish one or more entries, removing them from the Content Delivery API * **Type unpublish content, publish content** — Unpublish a content type so it can no longer be used to create new entries * **Action unpublish ai, publish ai, invoke ai** — Unpublish an AI action, removing it from the available actions in the editor * **Search entries** — Search for entries in a Contentful space using flexible query parameters including field filters and full-text search ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Context7 MCP connector > Connect to Context7 MCP to fetch up-to-date, version-specific library documentation and code examples directly from the source. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Context7 MCP credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. 4. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'context7mcp' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'context7mcp_query_docs', 19 toolInput: { libraryId: 'YOUR_LIBRARYID', query: 'YOUR_QUERY' }, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "context7mcp" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={"libraryId":"YOUR_LIBRARYID","query":"YOUR_QUERY"}, 19 tool_name="context7mcp_query_docs", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Id resolve library** — Search for a library by name and resolve it to a Context7-compatible library ID * **Query docs** — Fetch up-to-date, version-specific documentation and code examples for a library using its Context7 ID ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Conversion Tools MCP connector > Connect to Conversion Tools MCP. Convert files between 140+ formats including documents, images, audio, video, and data files from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'conversiontoolsmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Conversion Tools MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'conversiontoolsmcp_auth_status', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "conversiontoolsmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Conversion Tools MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="conversiontoolsmcp_auth_status", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Url request upload** — Get a signed URL for uploading large files (over 5 MB) * **List converters** — List available file converters * **Get converter info** — Get detailed information about a specific converter, including available options and their allowed values * **Converter find** — Find the best converter for converting between two specific formats * **File convert** — Convert a file between 140+ supported formats including documents, images, audio, video, and data files * **Status auth** — Check authentication status and account info ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # ConvertAPI MCP connector > Connect to ConvertAPI MCP. Convert, merge, split, and transform files across 200+ formats including PDF, Word, Excel, images, and more. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'convertapimcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize ConvertAPI MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'convertapimcp_get_converters_by_tags', 25 toolInput: { tags: [] }, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "convertapimcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize ConvertAPI MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={"tags":[]}, 27 tool_name="convertapimcp_get_converters_by_tags", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Search converters** — Search for available ConvertAPI converters that match the specified search terms * **Url request upload** — Generate a curl command to upload a local file to ConvertAPI and obtain a FileId * **Get converters by tags, conversion parameters** — Retrieve a list of available ConvertAPI converters that match all specified tags * **Convert records** — Convert a file from one format to another using ConvertAPI ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Crustdata MCP connector > People and company intelligence platform for candidate sourcing, sales prospecting, and talent intelligence. Provides real-time data on professionals... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'crustdatamcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Crustdata MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'crustdatamcp_crustdata_credits_check', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "crustdatamcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Crustdata MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="crustdatamcp_crustdata_credits_check", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Search crustdata web, crustdata people** — Search the web for information about companies, people, or topics * **Fetch crustdata web** — Fetch and extract text content from up to 10 web page URLs in one request * **Update crustdata watcher** — Update an existing watcher subscription * **Simulate crustdata watcher** — Simulate a watcher subscription to test your webhook endpoint * **Runs crustdata watcher** — List recent runs of a watcher * **Run crustdata watcher** — Fetch the detailed summary of a single watcher run: per-stage pipeline logs with timestamps AND the actual webhook payload(s) delivered for that run ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Customer.io MCP connector > Connect to Customer.io MCP to manage customers, campaigns, and events 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Customer.io MCP credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'customeriomcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Customer.io MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'customeriomcp_cio_auth_status', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "customeriomcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Customer.io MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="customeriomcp_cio_auth_status", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Api cio write** — Write to the Customer.io API (POST, PUT, or PATCH) * **Read cio skills, cio** — Read the full content of a specific Customer.io agent skill by path * **List cio skills** — List available Customer.io agent skills — task-specific instruction manuals covering campaigns, segments, deliveries, analytics, and more * **Schema cio** — Introspect the Customer.io API schema to discover endpoints, parameters, and response shapes * **Prime cio** — Print LLM-ready instructions for using the Customer.io API * **Delete cio** — Delete a resource via the Customer.io API (DELETE only) ## Common workflows [Section titled “Common workflows”](#common-workflows) ### Check authentication status Use `customeriomcp_cio_auth_status` to verify the connection and see the authenticated user, account, and accessible workspaces. * Node.js ```typescript 1 const status = await actions.executeTool({ 2 connectionName: 'customeriomcp', 3 identifier: 'user_123', 4 toolName: 'customeriomcp_cio_auth_status', 5 toolInput: {}, 6 }); 7 console.log(status); ``` * Python ```python 1 status = actions.execute_tool( 2 connection_name="customeriomcp", 3 identifier="user_123", 4 tool_name="customeriomcp_cio_auth_status", 5 tool_input={}, 6 ) 7 print(status) ``` ### Read campaign data Use `customeriomcp_cio_read_api` to fetch campaigns from a Customer.io environment. Call `customeriomcp_cio_schema` first to discover the correct API path and available parameters. * Node.js ```typescript 1 const campaigns = await actions.executeTool({ 2 connectionName: 'customeriomcp', 3 identifier: 'user_123', 4 toolName: 'customeriomcp_cio_read_api', 5 toolInput: { 6 path: '/v1/environments/{environment_id}/campaigns', 7 params: { environment_id: 'env_abc123' }, 8 limit: 10, 9 }, 10 }); 11 console.log(campaigns); ``` * Python ```python 1 campaigns = actions.execute_tool( 2 connection_name="customeriomcp", 3 identifier="user_123", 4 tool_name="customeriomcp_cio_read_api", 5 tool_input={ 6 "path": "/v1/environments/{environment_id}/campaigns", 7 "params": {"environment_id": "env_abc123"}, 8 "limit": 10, 9 }, 10 ) 11 print(campaigns) ``` ### Create a campaign Use `customeriomcp_cio_write_api` to create a new campaign. Always set `dry_run: true` first to validate the request before executing. * Node.js ```typescript 1 // Step 1 — dry run to validate 2 const preview = await actions.executeTool({ 3 connectionName: 'customeriomcp', 4 identifier: 'user_123', 5 toolName: 'customeriomcp_cio_write_api', 6 toolInput: { 7 path: '/v1/environments/{environment_id}/campaigns', 8 params: { environment_id: 'env_abc123' }, 9 body: { name: 'Welcome Series', type: 'triggered' }, 10 dry_run: true, 11 }, 12 }); 13 console.log(preview); 14 15 // Step 2 — execute after confirming dry run looks correct 16 const result = await actions.executeTool({ 17 connectionName: 'customeriomcp', 18 identifier: 'user_123', 19 toolName: 'customeriomcp_cio_write_api', 20 toolInput: { 21 path: '/v1/environments/{environment_id}/campaigns', 22 params: { environment_id: 'env_abc123' }, 23 body: { name: 'Welcome Series', type: 'triggered' }, 24 }, 25 }); 26 console.log(result); ``` * Python ```python 1 # Step 1 — dry run to validate 2 preview = actions.execute_tool( 3 connection_name="customeriomcp", 4 identifier="user_123", 5 tool_name="customeriomcp_cio_write_api", 6 tool_input={ 7 "path": "/v1/environments/{environment_id}/campaigns", 8 "params": {"environment_id": "env_abc123"}, 9 "body": {"name": "Welcome Series", "type": "triggered"}, 10 "dry_run": True, 11 }, 12 ) 13 print(preview) 14 15 # Step 2 — execute after confirming dry run looks correct 16 result = actions.execute_tool( 17 connection_name="customeriomcp", 18 identifier="user_123", 19 tool_name="customeriomcp_cio_write_api", 20 tool_input={ 21 "path": "/v1/environments/{environment_id}/campaigns", 22 "params": {"environment_id": "env_abc123"}, 23 "body": {"name": "Welcome Series", "type": "triggered"}, 24 }, 25 ) 26 print(result) ``` ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # SMART App on FHIR connector > SMART App on FHIR is a healthcare interoperability provider that enables secure access to electronic health records and clinical data using the SMART on... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your SMART App on FHIR credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update procedure, practitioner, patient** — Update an existing FHIR Procedure resource by its ID * **Search procedure, practitioner, patient** — Search for FHIR Procedure resources representing clinical actions performed on a patient using parameters like patient, status, code, and date * **Read procedure, practitioner, patient** — Retrieve a single FHIR Procedure resource by its logical ID * **Delete procedure, practitioner, patient** — Delete a FHIR Procedure resource by its logical ID * **Create procedure, practitioner, patient** — Create a new FHIR Procedure resource recording a clinical action performed on or for a patient * **Everything patient** — Invoke the $everything operation on a Patient to retrieve all clinical resources associated with that patient in a single Bundle response ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Dart AI MCP connector > AI-native project management tool for task and document management with deep AI integration. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'dartaimcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Dart AI MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'dartaimcp_get_config', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "dartaimcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Dart AI MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="dartaimcp_get_config", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update task description, task, doc text** — Apply targeted text updates to a task’s description * **Title retrieve skill by** — Retrieve a skill by its title * **Issue report** — Create a concise markdown issue report for Dart Support * **Task move** — Move a task to a specific position by placing it before or after another task * **List tasks, help center articles, docs** — List tasks with powerful filtering options * **Get view, task, folder** — Retrieve an existing view by its ID ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Databox MCP connector > Connect to Databox MCP. Query metrics, manage dashboards, and push custom data to your Databox analytics and reporting platform. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'databoxmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Databox MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'databoxmcp_get_current_datetime', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "databoxmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Databox MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="databoxmcp_get_current_datetime", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Data load metric, ingest** — Retrieve data points for a Databox metric over a date range with optional time-series granulation and dimension breakdown * **List metrics, merged datasets, data sources** — List all metrics available for a Databox data source, including metric keys, names, descriptions, and available dimensions * **Get ingestion, dataset ingestions, current datetime** — Get detailed information for a specific ingestion event, including status, timestamps, dataset metrics, and per-record ingestion outcomes * **Delete dataset, data source** — Permanently delete a dataset and all its data from Databox * **Create dataset, data source** — Create a structured dataset within a Databox data source, optionally defining a column schema and primary keys for tabular data storage * **Genie ask** — Ask Genie, the Databox AI data analyst, to explore and analyze a dataset using natural language ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Databricks Workspace connector > Connect to Databricks Workspace APIs using a Service Principal with OAuth 2.0 client credentials to manage clusters, jobs, notebooks, SQL, and more. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Schemata information schema** — List all schemas within a catalog using INFORMATION\_SCHEMA.SCHEMATA * **Constraints information schema table** — List PRIMARY KEY and FOREIGN KEY constraints for tables in a schema using INFORMATION\_SCHEMA.TABLE\_CONSTRAINTS * **List unity catalog schemas, unity catalog catalogs, unity catalog tables** — List all schemas within a Unity Catalog in the Databricks workspace * **Get sql statement result chunk, sql warehouse, sql statement** — Fetch a specific result chunk for a paginated SQL statement result * **Tables information schema** — List tables and views in a schema using INFORMATION\_SCHEMA.TABLES * **Columns information schema** — List columns for a table using INFORMATION\_SCHEMA.COLUMNS ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Datadog connector > Connect to Datadog to monitor metrics, logs, traces, dashboards, monitors, incidents, SLOs, synthetics, and security signals across your infrastructure. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Datadog credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. 4. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'datadog' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'datadog_containers_list', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "datadog" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="datadog_containers_list", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Get synthetics browser test, monitor, event** — Get a specific Datadog Synthetics browser test by public ID * **Create downtime, monitor, host tags** — Create a new Datadog downtime to suppress alerts * **Trigger synthetics test** — Trigger one or more Datadog Synthetics tests to run immediately * **Delete notebook, synthetics test, dashboard** — Delete a specific notebook by its ID * **List processes, log indexes, permissions** — List live processes running on your infrastructure * **Update slo, downtime, metric metadata** — Update an existing Datadog Service Level Objective ## Common workflows [Section titled “Common workflows”](#common-workflows) Downtime response includes two IDs The `downtime_create` response contains both `data.id` (the downtime UUID) and `included[].id` (the creator’s user UUID). Always use `data.id` for subsequent `downtime_get`, `downtime_update`, and `downtime_cancel` calls. ## Getting resource IDs [Section titled “Getting resource IDs”](#getting-resource-ids) Most tools require IDs that must be fetched from the API — never guess or hard-code them. | Resource | Tool to get ID | Field in response | | --------------- | ---------------------------------- | ------------------------------------------------------------ | | Monitor ID | `datadog_monitors_list` | `array[].id` | | Dashboard ID | `datadog_dashboards_list` | `dashboards[].id` | | Downtime ID | `datadog_downtime_create` response | `data.id` (UUID — not `included[].id`) | | Notebook ID | `datadog_notebooks_list` | `data[].id` | | Incident ID | `datadog_incidents_list` | `data[].id` | | SLO ID | `datadog_slos_list` | `data[].id` | | Role ID | `datadog_roles_list` | `data[].id` | | User ID | `datadog_users_list` | `data[].id` | | RUM App ID | `datadog_rum_applications_list` | `data[].id` | | Event ID | `datadog_event_create` response | `event.id_str` (**use `id_str`, not `id`** — see note below) | | Metric name | `datadog_metrics_list` | `metrics[]` (requires `from` Unix timestamp) | | Log pipeline ID | `datadog_log_pipelines_list` | `array[].id` | ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Dataforseo MCP connector > Connect to DataForSEO. Access real-time SEO data including SERP results, keyword analytics, backlinks analysis, domain technologies, and AI visibility... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'dataforseomcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Dataforseo MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'dataforseomcp_business_data_business_listings_search', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "dataforseomcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Dataforseo MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="dataforseomcp_business_data_business_listings_search", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Advanced serp youtube video subtitles live, serp youtube video info live, serp youtube video comments live** — Get subtitle text for a YouTube video by video ID and language * **Locations serp youtube, serp, merchant amazon** — List available locations for YouTube SERP data queries * **Lighthouse on page** — Run a Lighthouse performance and SEO audit for a web page URL * **Pages on page instant, dataforseo labs google relevant, backlinks domain** — Get on-page SEO data for a URL including metadata, links, and content metrics * **Parsing on page content** — Extract and parse text content from a web page URL * **Explore kw data google trends, kw data dfs trends** — Get Google Trends data for keywords over a time range and location ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Deel MCP connector > Global HR and payroll platform for hiring, paying, and managing international employees and contractors with built-in compliance. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'deelmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Deel MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'deelmcp_advance_eligibility_get', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "deelmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Deel MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="deelmcp_advance_eligibility_get", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Trigger workflow, workflow action** — Creates an internal invisible workflow with a trigger * **Get worker personal info external, worker hrx manager, verification method** — Retrieves a worker profile record using a system-wide external worker identifier * **List worker document, worker contract type, worker compliance document** — Retrieve a list of documents of a worker * **Download worker document, invoice, ic invoice** — Get the download link of worker document * **Sign worker contract, worker amendment, eor resignation letter** — Records the worker’s signature on the contract identified by contract\_id * **Update vms candidate, worker relation type external id, worker relation type** — Handles a candidate action event from an external provider by updating the candidate state and triggering corresponding platform workflows ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Deepgram MCP connector > Connect to Deepgram MCP. Transcribe audio, generate speech, and manage transcription projects using Deepgram's AI-powered speech recognition API. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'deepgrammcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Deepgram MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'deepgrammcp_search_deepgram_knowledge_sources', 25 toolInput: { query: 'YOUR_QUERY' }, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "deepgrammcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Deepgram MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={"query":"YOUR_QUERY"}, 27 tool_name="deepgrammcp_search_deepgram_knowledge_sources", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Search deepgram knowledge sources** — Search Deepgram documentation and knowledge sources for the most relevant results for a given query ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Descript MCP connector > Connect to Descript MCP. Import media, export transcripts, publish projects, run AI editing agents, and manage jobs from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'descriptmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Descript MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'descriptmcp_list_jobs', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "descriptmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Descript MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="descriptmcp_list_jobs", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Job wait for, cancel** — Poll a Descript job until it completes, streaming progress updates, with an optional timeout * **Project publish** — Publish a Descript project composition as video or audio and return a shareable URL * **Agent prompt project** — Use Descript’s AI agent to query, create, or edit a project using a natural language prompt * **List projects, jobs** — List Descript projects accessible to the authenticated user, with optional filtering and sorting * **Media import** — Import media into a Descript project from URLs (Google Drive, Dropbox, direct links) or direct file upload * **Get project** — Retrieve detailed information about a Descript project, including its media files and compositions ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Devin MCP connector > Connect to Devin MCP. Create and manage AI coding sessions, interact with Devin agents, manage playbooks and schedules, and browse repository wikis from... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Devin MCP credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. 4. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'devinmcp' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'devinmcp_devin_session_search', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "devinmcp" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="devinmcp_devin_session_search", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Read wiki structure, wiki contents** — Get a list of documentation topics for a GitHub repository * **List integrations, available repos** — List all native integrations and MCP servers for the organization with status and settings * **Wiki generate** — Generate a codebase wiki for a repository and wait for it to complete * **Search devin session** — Search and filter Devin sessions by date, tags, playbook, schedule, or user * **Interact devin session** — Interact with a Devin session — get status, send a message, sleep, or terminate * **Gather devin session** — Wait for multiple Devin sessions to reach a settled state before returning ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Dev Rev MCP connector > Connect to DevRev MCP. Manage issues, work items, conversations, and customer data in the DevRev product development platform. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Dev Rev MCP credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. 4. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'devrevmcp' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'devrevmcp_get_self', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "devrevmcp" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="devrevmcp_get_self", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update object** — Update fields on an existing DevRev object using a specified update action * **List objects** — List DevRev objects (issues, tickets, etc.) with optional filters using a specified list action * **Objects link** — Create a link between two DevRev objects using a specified link action * **Search hybrid** — Search across DevRev’s knowledge graph using natural language to find issues, tickets, articles, and other objects * **Get valid stage transitions, tool metadata, sprint board** — Return valid stage transitions for a given DevRev object type and its current stage * **Fetch object context** — Fetch contextual information about any DevRev object by its DON ID or display ID ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Diarize connector > Connect to Diarize to transcribe and diarize audio and video content from YouTube, X, Instagram, and TikTok. Submit transcription jobs and retrieve... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Diarize credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. 4. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'diarize' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'diarize_get_job_status', 19 toolInput: { job_id: 'YOUR_JOB_ID' }, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "diarize" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={"job_id":"YOUR_JOB_ID"}, 19 tool_name="diarize_get_job_status", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Get job status** — Retrieve the current status of a transcription job by its job ID * **Transcript download** — Download the transcript output for a completed transcription job in JSON, TXT, SRT, or VTT format, including speaker diarization, segments, and word-level timestamps * **Create transcription job** — Submit a new transcription and diarization job for an audio or video URL (YouTube, X, Instagram, TikTok) ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Digits MCP connector > Digits is an AI-powered business finance platform. This MCP connector gives AI agents read-only access to your Digits data — transactions, financial... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'digitsmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Digits MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'digitsmcp_list_businesses', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "digitsmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Digits MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="digitsmcp_list_businesses", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Business select** — Select a business to work with * **Search term** — Resolve a customer, vendor, category, department, location name or transaction description to its canonical form using fuzzy text matching * **Query transactions** — Query and filter individual transactions * **List locations, departments, categories** — This tool is used to list locations * **Statement financial** — Generate complete financial statements: Profit & Loss, Balance Sheet, Cash Flow, AR/AP Aging * **Transactions dimensional summarize** — Summarizes transactions and aggregates them into multi-dimensional summaries ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Discord connector > Connect to Discord. Read user profile, guilds, roles, manage bots, and perform interactions. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Discord credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'discord' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Discord:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'discord_get_gateway', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "discord" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Discord:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="discord_get_gateway", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Entitlement consume** — For one-time purchase consumable SKUs, mark a given entitlement for the user as consumed * **Create lobby channel invite for self, or join lobby** — Create a single-use guild invite to a lobby’s linked channel, targeted at the calling user * **Delete current user application role connection, test entitlement** — Deletes the application role connection for the current user and the given application * **Permissions edit application command** — Edit the permissions for a specific application command in a guild * **Get application command permissions, current user application entitlements, current user application role connection** — Fetch permissions for a specific application command in a guild * **Lobby leave, link channel to** — Remove the calling user from the specified Discord lobby ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Discord Bot connector > Connect to Discord as a bot. Manage guilds, channels, members, messages, roles, webhooks, and more using a Discord Bot Token. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Discord Bot credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. 4. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'discordbot' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'discordbot_get_current_application', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "discordbot" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="discordbot_get_current_application", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Member add guild, add lobby, add thread** — Add a user to a guild using their OAuth2 access token with the guilds.join scope * **Role add guild member, modify guild, remove guild member** — Add a role to a guild member * **Prune begin guild** — Begin a prune operation to kick inactive members * **Delete bulk, all reactions, all reactions for emoji** — Delete multiple messages in a Discord channel in a single request (2-100 messages) * **Ban bulk guild, remove guild** — Ban up to 200 users from a guild and optionally delete their recent messages * **Commands bulk overwrite global application, bulk overwrite guild application** — Bulk overwrite all global application commands ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Docsautomator MCP connector > Connect to DocsAutomator MCP. Generate documents and PDFs from templates using your data, automating document creation workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'docsautomatormcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Docsautomator MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'docsautomatormcp_get_queue_stats', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "docsautomatormcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Docsautomator MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="docsautomatormcp_get_queue_stats", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update automation esignature, automation** — Update the e-signature configuration of an automation: enable/disable signing, set signers, customize email templates and language, configure save-to-Drive * **Send test email** — Send a test email with a sample PDF to verify email configuration * **Invite resend esign** — Resend the signing invitation email to a specific signer * **Complete poll job until** — Poll a job until it completes or times out * **List placeholders, esign sessions, automations** — Extract all placeholders from a Google Doc template * **Get signing links, queue stats, job status** — Get signing links for all signers in a session ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Dovetail MCP connector > Connect to Dovetail, the AI-native UX research platform. Access projects, insights, and data from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'dovetailmcp' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'dovetailmcp_get_dovetail_projects', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "dovetailmcp" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="dovetailmcp_get_dovetail_projects", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Search workspace** — Perform powerful text-based search across all content types in the Dovetail workspace — projects, docs, data, highlights, and contacts * **List users, tags, project templates** — List all members of the Dovetail workspace, including their roles and contact information * **Get user, tag, project insight** — Retrieve a single workspace member’s profile by their unique identifier * **File download** — Get a short-lived presigned URL to download the raw content of a file attachment * **Create transcript highlight, tag, project** — Create a highlight on an audio or video transcript by marking a specific text range ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Dropbox connector > Connect to Dropbox. Manage files, folders, sharing, and cloud storage workflows 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Dropbox credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'dropbox' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Dropbox:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'dropbox_file_requests_list', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "dropbox" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Dropbox:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="dropbox_file_requests_list", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Get users, sharing** — Get the current storage space usage for the authenticated Dropbox user, including used and allocated space * **Folder sharing share** — Share a Dropbox folder with other users * **Link sharing revoke shared** — Revoke a shared link in Dropbox, making it inaccessible * **List sharing, files** — List shared links for a file or folder in Dropbox * **Create sharing, files, file requests** — Create a shared link for a file or folder in Dropbox with optional visibility and access settings * **Member sharing add folder** — Add one or more members to a Dropbox shared folder ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Dropbox MCP connector > Connect to Dropbox. Manage files and folders, create shared links, search content, and handle file requests from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Dropbox MCP credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'dropboxmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Dropbox MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'dropboxmcp_check_job_status', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "dropboxmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Dropbox MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="dropboxmcp_check_job_status", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **I who am** — Retrieve the current Dropbox account profile information * **Search records** — Search for files and folders in Dropbox by query with optional filters * **Move records** — Move one or more files or folders to a new location in Dropbox * **List shared links, folder, file requests** — List shared links for the account or a specific path with pagination * **Get usage and quota, shared link metadata, file request** — Retrieve the current storage usage and quota for the Dropbox account * **Link download** — Get temporary download URLs for one or more files ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Dropcontact MCP connector > B2B contact enrichment and email verification platform that finds, verifies, and enriches professional email addresses and company data. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'dropcontactmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Dropcontact MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'dropcontactmcp_check_credits', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "dropcontactmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Dropcontact MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="dropcontactmcp_check_credits", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Validation submit email** — Submit an email validation request to check whether an email address is valid and deliverable * **Name submit contact enrichment by, submit contact enrichment by full** — Submit a contact enrichment request using first name, last name, and company name * **Linkedin submit contact enrichment by** — Submit a contact enrichment request using a LinkedIn profile URL * **Result retrieve enrichment** — Retrieve the result of a previously submitted enrichment or email validation request * **Credits check** — Check the number of remaining Dropcontact enrichment credits for the authenticated user ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Dynamo Software connector > Connect to Dynamo Software API to access investment management, CRM, and reporting data. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'dynamo' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'dynamo_get_document_extended_schema', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "dynamo" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="dynamo_get_document_extended_schema", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Search records** — Retrieves data matching saved search criteria from Dynamo using advanced filter queries * **Get view sql, document schema, view** — Returns data from a specific SQL view in Dynamo using the view name * **Delete entity, bulk** — Deletes a single instance of the specified Dynamo entity by ID * **Total entity** — Returns total count of items for a given Dynamo entity * **Id entity by** — Returns a single instance of a Dynamo entity by its ID with optional column selection and formatting controls * **Key reset api** — Removes the user’s API key from the server cache ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Echtpost MCP connector > Connect to Echtpost MCP. Send physical postcards and letters programmatically via the Echtpost API. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'echtpostmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Echtpost MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'echtpostmcp_get_me', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "echtpostmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Echtpost MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="echtpostmcp_get_me", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update group, contact** — Update a contact group * **Fit preview** — Check if a message fits on a postcard with the given font settings * **List templates, motives, groups** — List available card templates for the account * **Get template, motive, me** — Get details of a specific template by ID * **Delete group, contact** — Delete a contact group * **Create group, contact, card from template** — Create a new contact group ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Eden MCP connector > Eden is an AI-powered content creation platform that discovers viral trends across 3M+ social media posts and helps creators generate content in their... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'edenmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Eden MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'edenmcp_eden_analyze_list', 25 toolInput: { listId: 'YOUR_LISTID' }, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "edenmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Eden MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={"listId":"YOUR_LISTID"}, 27 tool_name="edenmcp_eden_analyze_list", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Index eden wait for creator** — Wait for a creator’s content index to be ready before querying * **Media eden upload scheduling** — Upload media for use in scheduled posts using a pre-signed URL * **Update eden** — Update an existing AI skill’s name, description, or definition by skill ID * **Board eden trash, eden save posts to, eden save links to** — Move a board to trash * **Carousels eden study top** — Study the top-performing carousels for inspiration and patterns * **Comment eden set first** — Set the first comment on a scheduled post (for auto-commenting after publish) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # EODHD MCP connector > EODHD (End of Day Historical Data) provides comprehensive financial market data including end-of-day stock prices, historical OHLCV data, fundamentals... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'eodhdmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize EODHD MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'eodhdmcp_get_asx_corporate_actions', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "eodhdmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize EODHD MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="eodhdmcp_get_asx_corporate_actions", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Screener stock** — Screen and filter stocks by fundamental and technical criteria * **Id retrieve description by** — Retrieve built-in EODHD API documentation by numeric type and id * **Ticker resolve** — Resolve a company name, partial ticker, or ISIN to SYMBOL.EXCHANGE format (and ISIN) * **List mp indices** — \[Marketplace] List all available S\&P and Dow Jones indices with end-of-day details * **Components mp index** — \[Marketplace] Get constituent stocks of a specific S\&P or Dow Jones index, including historical component changes for major indices * **Insights mp illio risk, mp illio performance** — \[Illio] Retrieve portfolio-level risk attributes for a major US index ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Era Context MCP connector > Connect to Era Context MCP. Access personal finance data including transactions, accounts, spending insights, and AI-powered financial knowledge from Era. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'eracontextmcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Era Context MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'eracontextmcp_accounts__list_financial_accounts', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "eracontextmcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Era Context MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="eracontextmcp_accounts__list_financial_accounts", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * \*\*Update transactions \*\* — Bulk-update up to 100 transactions: set category, description, merchant name, or review status * \*\*Search transactions \*\* — Search and filter transactions by merchant name, description, amount range, category, date range, and direction (debit/credit) * **Links transactions manage transfer** — List, confirm, or reject system-detected transfer pairs between transactions (e.g * **Tags transactions manage transaction** — Create, list, update, delete, assign, or remove user-defined tags on transactions * **Transaction transactions manage manual** — Create, update, or delete transactions on a manual account * **Categories transactions manage** — Create, update, hide, delete, merge, or reorder spending categories ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Eraser MCP connector > Connect to Eraser MCP. Create and edit diagrams, flowcharts, and technical documentation using Eraser's AI-powered diagramming tools. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'erasermcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Eraser MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'erasermcp_get_me', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "erasermcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Eraser MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="erasermcp_get_me", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update template or reference, rules, preset** — Rename a template or reference file * **Team select** — Set the active team for the session when the user belongs to multiple teams (OAuth only) * **Search records** — Full-text and semantic search across files or diagrams * **Reference publish template or, add or remove template or** — Publish a new version of a template/reference file * **Create manually, template or reference** — ADVANCED — most callers should use create\_document instead * **List teams, presets, folders** — List the teams the current user belongs to (OAuth only) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Evertrace AI connector > Connect to evertrace.ai to search and manage talent signals, saved searches, and lists. Access rich professional profiles with scoring, experiences, and... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'evertrace' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'evertrace_cities_list', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "evertrace" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="evertrace_cities_list", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **List companies, entries delete, entries get** — Search companies by name or look up by specific IDs * **Delete lists, searches** — Permanently delete a list and all its entries * **Update lists, searches** — Rename a list * **Get lists, signals, searches** — Get a list by ID with its entries, accesses, and creator information * **Create lists, searches** — Create a new list * **Viewed signal mark** — Mark a signal as viewed by the current user ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Exa connector > Connect to Exa to perform AI-powered semantic web search, crawl websites for structured content, get natural language answers from the web, run in-depth... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Exa credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. 4. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'exa' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'exa_list_websets', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "exa" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="exa_list_websets", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Similar find** — Find web pages similar to a given URL using Exa’s neural similarity search * **Search records** — Search the web using Exa’s AI-powered semantic or keyword search engine * **Research records** — Run in-depth research on a topic using Exa’s neural search * **Crawl records** — Crawl one or more web pages by URL and extract their content including full text, highlights, and AI-generated summaries * **List websets, webset items** — List all Exa Websets in your account with optional pagination * **Websets records** — Execute a complex web query designed to discover and return large sets of URLs (up to thousands) matching specific criteria ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Exa MCP connector > Connect to Exa MCP to perform AI-powered semantic web search, crawl websites for structured content, get natural language answers from the web, and run... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Exa MCP credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. 4. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'examcp' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'examcp_web_fetch_exa', 19 toolInput: { urls: [] }, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "examcp" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={"urls":[]}, 19 tool_name="examcp_web_fetch_exa", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Search web** — Search the web and get clean, ready-to-use content * **Fetch web** — Read one or more webpages and return their full content as clean markdown ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Excalidraw MCP connector > Excalidraw+ is a collaborative whiteboard and diagramming platform. The Excalidraw MCP server lets AI agents manage scenes, collections, workspaces... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'excalidrawmcp' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'excalidrawmcp_get_workspace', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "excalidrawmcp" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="excalidrawmcp_get_workspace", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update workspace user, workspace, scene** — Modify workspace-level properties for a specific user such as their name, picture, or role * **Screenshot take** — Render a scene, or a specific frame, as a PNG image so you can visually inspect the current Excalidraw content * **Search scene content** — Search a scene’s shapes and text without loading the full scene content * **User remove workspace** — Remove a user from the workspace * **Read excalidraw format** — Returns the Excalidraw element format reference with agent-facing rules for constructing valid diagram payloads * **List workspace users, scenes, logs** — Retrieve a paginated list of all members in the current workspace ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Expo MCP connector > Expo is a platform for building universal React Native apps; its MCP server exposes developer services including EAS builds, submissions, and project... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'expomcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Expo MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'expomcp_build_list', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "expomcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Expo MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="expomcp_build_list", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Validate workflow** — Validates an EAS workflow YAML file for syntax and configuration errors * **Run workflow, build** — Triggers an EAS workflow run for a project * **Logs workflow, build** — Fetches logs for a specific job in an EAS workflow run * **List workflow, build** — Lists recent EAS workflow runs for a project * **Info workflow, build** — Fetches detailed information about a specific EAS workflow run by ID including status, job results, errors, and artifacts * **Create workflow** — Creates a new EAS workflow YAML file for Expo projects or fetches workflow syntax documentation ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Fathom connector > Connect to Fathom AI meeting assistant. Record, transcribe, and summarize meetings with AI-powered insights 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Fathom credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment. 4. ### Make your first call [Section titled “Make your first call”](#make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'fathom' 12 const identifier = 'user_123' 13 14 // Make your first call 15 const result = await actions.executeTool({ 16 connector, 17 identifier, 18 toolName: 'fathom_list_meeting_types', 19 toolInput: {}, 20 }) 21 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "fathom" 14 identifier = "user_123" 15 16 # Make your first call 17 result = actions.execute_tool( 18 tool_input={}, 19 tool_name="fathom_list_meeting_types", 20 connection_name=connection_name, 21 identifier=identifier, 22 ) 23 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **List teams, team members, meetings** — List all teams configured in Fathom * **Get recording transcript, recording summary** — Retrieve the full transcript for a specific Fathom recording by its recording ID * **Delete webhook** — Delete a webhook subscription in Fathom by its ID * **Create webhook** — Create a new webhook subscription in Fathom ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Fathom MCP connector > Connect to Fathom MCP to access AI meeting notes, summaries, transcripts, and recordings from your AI workflows. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'fathommcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Fathom MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'fathommcp_get_identity', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "fathommcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Fathom MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="fathommcp_get_identity", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Search meetings** — Search meeting summaries and titles by topic or keyword (AND logic) * **List teams, meetings** — List all Fathom teams the current user belongs to * **Get recording by url, recording by call id, meeting transcript** — Resolve a Fathom URL to a recording\_id plus title, date, and url * **Person find** — Find a person by name across meeting speakers, then return contact info and compact summaries for matched meetings ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # FellowAI MCP connector > Connect to Fellow.ai MCP to manage meeting notes, action items, agendas, and team collaboration workflows directly from your AI agent. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your FellowAI MCP credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'fellowaimcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize FellowAI MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'fellowaimcp_get_action_items', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "fellowaimcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize FellowAI MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="fellowaimcp_get_action_items", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Search meetings** — Search for meetings across calendar events and notes, with filters for participants, date range, content, and summary * **List channels** — List all available channels in the workspace, optionally filtered by name or type * **Get meeting transcript, meeting summary, meeting participants** — Retrieve the transcript of a meeting ## Common workflows [Section titled “Common workflows”](#common-workflows) ### Search for recent meetings Use `fellowaimcp_search_meetings` to find meetings by title, date range, participants, or content. Set `user_has_calendar_event: true` to search only the current user’s own meetings. * Node.js ```typescript 1 const meetings = await actions.executeTool({ 2 connectionName: 'fellowaimcp', 3 identifier: 'user_123', 4 toolName: 'fellowaimcp_search_meetings', 5 toolInput: { 6 from_date: '2024-01-01', 7 to_date: '2024-01-31', 8 user_has_calendar_event: true, 9 has_summary: true, 10 }, 11 }); 12 console.log(meetings); ``` * Python ```python 1 meetings = actions.execute_tool( 2 connection_name="fellowaimcp", 3 identifier="user_123", 4 tool_name="fellowaimcp_search_meetings", 5 tool_input={ 6 "from_date": "2024-01-01", 7 "to_date": "2024-01-31", 8 "user_has_calendar_event": True, 9 "has_summary": True, 10 }, 11 ) 12 print(meetings) ``` ### Get a meeting summary Use `fellowaimcp_get_meeting_summary` to retrieve AI-generated summaries for one or more meetings, including key points, decisions, and action items. * Node.js ```typescript 1 const summary = await actions.executeTool({ 2 connectionName: 'fellowaimcp', 3 identifier: 'user_123', 4 toolName: 'fellowaimcp_get_meeting_summary', 5 toolInput: { 6 meeting_ids: ['meeting_abc123'], 7 }, 8 }); 9 console.log(summary); ``` * Python ```python 1 summary = actions.execute_tool( 2 connection_name="fellowaimcp", 3 identifier="user_123", 4 tool_name="fellowaimcp_get_meeting_summary", 5 tool_input={ 6 "meeting_ids": ["meeting_abc123"], 7 }, 8 ) 9 print(summary) ``` ### Fetch overdue action items Use `fellowaimcp_get_action_items` to retrieve action items assigned to the user, filtered by status or date range. * Node.js ```typescript 1 const actionItems = await actions.executeTool({ 2 connectionName: 'fellowaimcp', 3 identifier: 'user_123', 4 toolName: 'fellowaimcp_get_action_items', 5 toolInput: { 6 is_overdue: true, 7 }, 8 }); 9 console.log(actionItems); ``` * Python ```python 1 action_items = actions.execute_tool( 2 connection_name="fellowaimcp", 3 identifier="user_123", 4 tool_name="fellowaimcp_get_action_items", 5 tool_input={ 6 "is_overdue": True, 7 }, 8 ) 9 print(action_items) ``` ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Fever MCP connector > Fever is a live entertainment discovery platform. This MCP connector gives AI assistants direct access to Fever's global event catalog — search events by... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'fevermcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Fever MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'fevermcp_search_events', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "fevermcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Fever MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="fevermcp_search_events", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Search events, cities** — Find events, activities, and experiences available in a specific city through Fever ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Fibery MCP connector > Connect to Fibery MCP. Query, create, and update entities across your Fibery workspace using the Fibery API and AI assistant. 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'fiberymcp' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Fibery MCP:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'fiberymcp_get_connectors_list', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "fiberymcp" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Fibery MCP:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="fiberymcp_get_connectors_list", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Update workflow field, view, single select fields** — Updates the options of an existing workflow (state) field * **State set** — Sets the workflow state of a Fibery entity * **Content set document, append document** — Sets (replaces) the content of a document field on a Fibery entity * **Search history, guide** — Searches the workspace activity history and returns matching history events * **Detailed schema** — Returns detailed schema for specified databases, including fields and related databases * **Schema records** — Returns the high-level workspace structure showing all spaces and databases ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Figma connector > Connect to Figma to access user files, teams, projects, and design metadata via OAuth 2.0 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Set up the connector [Section titled “Set up the connector”](#set-up-the-connector) Register your Figma credentials with Scalekit so it handles the token lifecycle. You do this once per environment. 4. ### Authorize and make your first call [Section titled “Authorize and make your first call”](#authorize-and-make-your-first-call) * Node.js quickstart.ts ```typescript 1 import { ScalekitClient } from '@scalekit-sdk/node' 2 import 'dotenv/config' 3 4 const scalekit = new ScalekitClient( 5 process.env.SCALEKIT_ENV_URL, 6 process.env.SCALEKIT_CLIENT_ID, 7 process.env.SCALEKIT_CLIENT_SECRET, 8 ) 9 const actions = scalekit.actions 10 11 const connector = 'figma' 12 const identifier = 'user_123' 13 14 // Generate an authorization link for the user 15 const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) 16 console.log('Authorize Figma:', link) 17 process.stdout.write('Press Enter after authorizing...') 18 await new Promise(r => process.stdin.once('data', r)) 19 20 // Make your first call 21 const result = await actions.executeTool({ 22 connector, 23 identifier, 24 toolName: 'figma_activity_logs_list', 25 toolInput: {}, 26 }) 27 console.log(result) ``` * Python quickstart.py ```python 1 import os 2 from scalekit.client import ScalekitClient 3 from dotenv import load_dotenv 4 load_dotenv() 5 6 scalekit_client = ScalekitClient( 7 env_url=os.getenv("SCALEKIT_ENV_URL"), 8 client_id=os.getenv("SCALEKIT_CLIENT_ID"), 9 client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), 10 ) 11 actions = scalekit_client.actions 12 13 connection_name = "figma" 14 identifier = "user_123" 15 16 # Generate an authorization link for the user 17 link_response = actions.get_authorization_link( 18 connection_name=connection_name, 19 identifier=identifier, 20 ) 21 print("Authorize Figma:", link_response.link) 22 input("Press Enter after authorizing...") 23 24 # Make your first call 25 result = actions.execute_tool( 26 tool_input={}, 27 tool_name="figma_activity_logs_list", 28 connection_name=connection_name, 29 identifier=identifier, 30 ) 31 print(result) ``` ## What you can do [Section titled “What you can do”](#what-you-can-do) Connect this agent connector to let your agent: * **Get project meta, webhook, file variables local** — Retrieve metadata for a Figma project by its project ID * **Delete comment reaction, dev resource, file comment** — Removes the authenticated user’s emoji reaction from a comment in a Figma file * **List file components, file component sets, file styles** — Returns a list of all published components in a Figma file, including their keys, names, descriptions, and thumbnails * **Create file comment, webhook, comment reaction** — Posts a new comment on a Figma file * **Update file variables, webhook, dev resource** — Create, update, or delete variables, variable collections, and modes in a Figma file * **Render file images** — Renders nodes from a Figma file as images (PNG, JPG, SVG, or PDF) and returns URLs to download them ## Common workflows [Section titled “Common workflows”](#common-workflows) ## Tool list [Section titled “Tool list”](#tool-list) Use the exact tool names from the **Tool list** below when you call `execute_tool`. If you’re not sure which name to use, list the tools available for the current user first. Filter tools… --- # DOCUMENT BOUNDARY --- # Financial Datasets MCP connector > Financial Datasets provides an MCP interface to financial data APIs covering stock prices, financial statements, earnings, insider trades, and... 1. ### Install the SDK [Section titled “Install the SDK”](#install-the-sdk) * Node.js ```bash 1 npm install @scalekit-sdk/node ``` * Python ```bash 1 pip install scalekit ``` Full SDK reference: [Node.js](/agentkit/sdks/node/) | [Python](/agentkit/sdks/python/) 2. ### Set your credentials [Section titled “Set your credentials”](#set-your-credentials) Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. .env ```sh SCALEKIT_ENVIRONMENT_URL=