# Introduction
import { Cards, Card } from "fumadocs-ui/components/card";
**For AI agents:** Start with the Markdown entry point at [`/llms.txt`](/llms.txt). Individual pages are also available as `.mdx` exports (for example, [`/docs/getting-started/basic-usage.mdx`](/docs/getting-started/basic-usage.mdx)).
The Integrate SDK is a universal, type-safe TypeScript library that bridges your applications to third-party services through the Model Context Protocol (MCP). It provides seamless integration with services like GitHub, Gmail, Notion, and more, both in the browser and on the server, without the complexity of managing OAuth flows, API differences, or connection states.
Why Integrate SDK? [#why-integrate-sdk]
Building applications that connect to multiple third-party services is challenging. Each service has its own OAuth implementation, API quirks, and authentication patterns. You need to handle OAuth flows in the browser, manage tokens securely, make API calls from your backend, and deal with re-authentication when tokens expire.
The Integrate SDK solves this by providing a unified, type-safe interface to all your integrations. You configure your OAuth credentials once, authorize users through a seamless flow (popup or redirect), and then make API calls from anywhere in your stack, whether that's client-side JavaScript, server-side API routes, or serverless functions. The SDK handles token management, streaming connections to the MCP server, and provides full TypeScript support so you know exactly what tools are available and what parameters they need.
How It Works [#how-it-works]
The SDK connects to the Integrate MCP server (`https://mcp.integrate.dev/api/v1/mcp`) using HTTP streaming with newline-delimited JSON. You bring your own OAuth app credentials for each integration you want to use, whether that's a GitHub OAuth app, Google Cloud project, or Notion integration.
When a user authorizes your app, the OAuth flow happens through the server, which securely stores the credentials. The SDK receives a session token that it uses for all subsequent API calls. This token works everywhere: in the browser for rich user experiences, in your Next.js API routes for server-side operations, or in your Node.js backend services.
**Important:** You control your own OAuth applications and credentials. The SDK acts as a secure bridge, sending your OAuth configuration to the Integrate server which handles the complex authentication flows and API calls on your behalf.
Features [#features]
The Integrate SDK is designed to be both powerful and simple to use:
* π **Integration-Based Architecture** - Enable only the integrations you need, reducing bundle size and surface area
* π **Type-Safe** - Full TypeScript support with IntelliSense for every tool, parameter, and response
* π **Real-time Communication** - HTTP streaming with NDJSON for efficient, real-time data flow
* π **Complete OAuth Flow** - Built-in OAuth 2.0 with PKCE support in both popup and redirect modes
* β° **Scheduled Triggers** - Schedule tool executions for specific times or recurring intervals with cron expressions
* π **Universal** - Works seamlessly in browsers, Node.js, Edge runtimes, and serverless environments
* π οΈ **Extensible** - Add any integration supported by the Integrate MCP server with simple integration configuration
* π¦ **Zero Dependencies** - Lightweight implementation with no external dependencies
* π **Automatic Re-authentication** - Handle token expiration gracefully with built-in re-auth flows
* π― **Tool Discovery** - Automatically discover available tools based on your enabled integrations
Get Started [#get-started]
The Journey of an Integration [#the-journey-of-an-integration]
Here's what happens when you integrate a third-party service into your application:
1. Configuration [#1-configuration]
You configure the SDK with integrations for each service you want to use: GitHub for repository management, Gmail for email, Notion for knowledge base access, and so on. Each integration knows what OAuth credentials it needs and what tools it provides.
2. Authorization [#2-authorization]
When a user needs to connect their account, the SDK orchestrates the OAuth 2.0 flow. In the browser, this happens seamlessly through a popup or redirect. The user authorizes your app with the third-party service, and the Integrate server securely stores their credentials.
3. Connection [#3-connection]
The SDK establishes a streaming connection to `https://mcp.integrate.dev/api/v1/mcp` and receives a session token. This token is your golden ticket: it represents the user's authorized connections and works anywhere in your application.
4. Discovery [#4-discovery]
The SDK queries the server for available tools and intelligently filters them based on your enabled integrations. With full TypeScript support, your IDE immediately knows what tools are available, what parameters they accept, and what they return.
5. Execution [#5-execution]
When you call a tool (for example, creating a GitHub issue or sending an email), the SDK sends a JSON-RPC request over the streaming connection. The server executes the action using the stored OAuth credentials and streams the response back to your application.
6. Persistence [#6-persistence]
Session tokens can be persisted across page reloads and shared between client and server. Once a user has authorized your app in the browser, your backend services can use the same token to make API calls on their behalf.
Universal by Design [#universal-by-design]
The SDK adapts to its environment, providing the right capabilities for each context:
π Browser Environments [#-browser-environments]
In the browser, the SDK provides the complete user experience. Users can authorize their accounts through intuitive popup or redirect flows. The SDK manages session tokens, makes API calls, and handles re-authentication when needed. It's perfect for building rich, interactive experiences where users directly interact with their connected services.
π₯οΈ Server Environments [#οΈ-server-environments]
On the server, whether that's Node.js, Edge runtimes, or serverless functions, the SDK focuses on execution. Given a valid session token (typically obtained from browser authorization and passed via cookies or headers), it makes API calls efficiently without any UI concerns. This is ideal for backend operations, scheduled jobs, or API routes that need to interact with third-party services on behalf of users.
π The Typical Pattern [#-the-typical-pattern]
Most applications follow this pattern: handle OAuth authorization in the browser where users can interact with the authorization UI, then share the session token with your backend through secure HTTP-only cookies or authorization headers. Your server-side code can then make API calls using the same session token, maintaining a seamless experience across your entire stack.
Technical Details [#technical-details]
The SDK communicates with the Integrate MCP server using the Model Context Protocol:
* **Endpoint:** `https://mcp.integrate.dev/api/v1/mcp`
* **Protocol:** MCP over HTTP streaming for real-time, efficient communication
* **Format:** Newline-delimited JSON (NDJSON) for progressive responses
* **Methods:** `initialize`, `tools/list`, `tools/call` for complete integration lifecycle
* **Security:** OAuth 2.0 with PKCE for secure authorization flows
# Drizzle
The Drizzle adapter stores provider tokens and triggers using your existing Drizzle schema.
Install [#install]
```bash
bun add integrate-sdk drizzle-orm
```
`drizzle-orm` is a peer dependency of the adapter.
Schema [#schema]
Define `provider_token` and optional `trigger` tables. You can copy the [reference schema](/docs/database/schema) or align your existing tables with the same column names.
```typescript
// db/schema/integrate.ts
import { integrateProviderToken, integrateTrigger } from "integrate-sdk/server";
export const providerToken = integrateProviderToken;
export const trigger = integrateTrigger;
```
Configuration [#configuration]
```typescript
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
import { drizzleAdapter } from "integrate-sdk/adapters/drizzle";
import { db } from "./db";
import { providerToken, trigger } from "./db/schema";
export const { client } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [githubIntegration({ scopes: ["repo"] })],
database: drizzleAdapter(db, {
provider: "pg", // "pg" | "mysql" | "sqlite"
schema: { providerToken, trigger },
hooks: {
onTokenChange: ({ userId }) => revalidateTag(`integrations:${userId}`),
},
}),
getSessionContext: async (req) => {
const session = await auth.api.getSession({ headers: req.headers });
return session?.user?.id ? { userId: session.user.id } : undefined;
},
});
```
Session context example [#session-context-example]
Integrate's Drizzle adapter persists **integration OAuth tokens** in `provider_token`. It is separate from your app's user/session tablesβwire `getSessionContext` to whatever auth layer you already use.
```typescript
import { auth } from "./auth";
import { drizzleAdapter } from "integrate-sdk/adapters/drizzle";
database: drizzleAdapter(db, {
provider: "pg",
schema: { providerToken, trigger },
}),
getSessionContext: async (req) => {
const session = await auth.api.getSession({ headers: req.headers });
if (!session?.user?.id) return undefined;
return {
userId: session.user.id,
organizationId: session.session?.activeOrganizationId,
};
},
```
API [#api]
```typescript
drizzleAdapter(db, {
provider: "pg",
schema: { providerToken, trigger? },
hooks?: IntegrateAdapterHooks,
debugLogs?: boolean,
})
```
Returns a lazy factory `() => IntegrateDatabaseCallbacks` compatible with `createMCPServer({ database })`.
You can also use `drizzleAdapterCallbacks(db, config)` if you need the callback object directly without the factory wrapper.
Multi-account tokens [#multi-account-tokens]
The adapter handles multiple accounts per provider via `account_email` and `account_id`. See [Schema](/docs/database/schema) for the recommended unique index.
Example [#example]
See the [Drizzle database example](https://github.com/integratedotdev/examples/tree/main/database/drizzle-example) for a complete Next.js app with SQLite and GitHub OAuth.
# Hooks
Database adapters accept optional `hooks` to customize token persistence and trigger authorization without forking the SDK.
```typescript
drizzleAdapter(db, {
provider: "pg",
schema: { providerToken, trigger },
hooks: {
onTokenChange: async ({ userId, provider, action }) => { /* ... */ },
resolveAccountIdentity: async (provider, tokenData, emailHint, context) => { /* ... */ },
authorizeTrigger: async (row, context) => { /* ... */ },
},
});
```
onTokenChange [#ontokenchange]
Called after a token is saved or removed.
```typescript
onTokenChange: ({ userId, provider, action }) => {
// action: "set" | "remove"
revalidateTag(`library-integrations:${userId}`);
},
```
Use for cache invalidation, analytics, or webhooks.
resolveAccountIdentity [#resolveaccountidentity]
Resolve `account_email` and `account_id` before upserting a token. The default derives `accountId` from `provider:email` when email is known.
For GitHub, fetch the user's profile when email is missing:
```typescript
resolveAccountIdentity: async (provider, tokenData, emailHint) => {
let accountEmail = normalizeAccountEmail(emailHint);
let accountId = tokenData.accountId ?? null;
if (provider === "github" && (!accountEmail || !accountId)) {
const identity = await resolveGitHubIdentity(tokenData.accessToken);
accountEmail = accountEmail ?? identity.accountEmail;
accountId = accountId ?? identity.accountId;
}
if (!accountId && accountEmail) {
accountId = `${provider}:${accountEmail}`;
}
return { accountEmail, accountId };
},
```
Import helpers from `integrate-sdk/server`:
```typescript
import { normalizeAccountEmail } from "integrate-sdk/server";
```
authorizeTrigger [#authorizetrigger]
Called when loading or mutating a trigger. Return a (possibly updated) row, or `null` to deny access.
Use for ownership repair when `user_id` on the trigger row is stale:
```typescript
authorizeTrigger: async (row) => {
const ownerId = await resolveOwnerFromAutomationTables(row.id);
if (ownerId && ownerId !== row.userId) {
await db.update(trigger).set({ userId: ownerId }).where(eq(trigger.id, row.id));
return { ...row, userId: ownerId };
}
return row;
},
```
After the hook, the adapter checks `context.userId` against the returned row's `userId`.
getSessionContext (not a hook) [#getsessioncontext-not-a-hook]
Session resolution stays on `createMCPServer`, not the adapter. Wire your auth library or internal headers:
```typescript
getSessionContext: async (req) => {
const internal = resolveCronActor(req);
if (internal) return internal;
const session = await auth.api.getSession({ headers: req.headers });
return session?.user?.id ? { userId: session.user.id } : undefined;
},
```
Raw callbacks override hooks [#raw-callbacks-override-hooks]
If you pass explicit `getProviderToken` / `setProviderToken` / `removeProviderToken` or individual `triggers.*` callbacks on `createMCPServer`, those take precedence over the adapter. Hooks still run inside the adapter for operations the adapter handles.
# Database
The Integrate SDK can persist OAuth provider tokens and scheduled triggers in your database instead of relying on hand-written callbacks for every CRUD operation. This enables:
* **Multi-device sync**: Access tokens across devices and sessions
* **Server-side usage**: Use tokens in API routes and background jobs
* **Long-term persistence**: Tokens survive browser clears and device changes
* **Trigger storage**: Schedule tool executions with database-backed triggers
Adapters vs callbacks [#adapters-vs-callbacks]
You can configure persistence in two ways:
| Approach | When to use |
| ---------------------------------- | ------------------------------------------------------------------------------ |
| **Database adapter** (recommended) | Drizzle, Prisma, or MongoDB. Same callback shape as hand-written token storage |
| **Raw callbacks** | Custom storage, legacy setups, or non-standard schemas |
With adapters, pass `database` to `createMCPServer`. Token and trigger CRUD are handled for you. You still provide **`getSessionContext`** to map requests to a `userId` (session cookie, Clerk, service headers, etc.).
```typescript
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
import { drizzleAdapter } from "integrate-sdk/adapters/drizzle";
import { db } from "./db";
import { providerToken, trigger } from "./db/schema";
export const { client } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [githubIntegration({ scopes: ["repo"] })],
database: drizzleAdapter(db, {
provider: "pg",
schema: { providerToken, trigger },
}),
getSessionContext: async (req) => {
const session = await auth.api.getSession({ headers: req.headers });
return session?.user?.id ? { userId: session.user.id } : undefined;
},
});
```
Explicit callbacks on `createMCPServer` still work and **override** adapter defaults when both are set.
Connected-provider tool loading [#connected-provider-tool-loading]
When using a database adapter, pair token storage with [connected-only tool discovery](/docs/guides/mcp-tool-scoping):
```typescript
import { getVercelAITools } from "integrate-sdk/server";
const tools = await getVercelAITools(serverClient, {
context: { userId: session.user.id },
connectedOnly: true,
mode: "code",
});
```
Use `listConnectedProviders` from `integrate-sdk/server` when you need the connected provider list outside AI helpers.
Guides [#guides]
* [Drizzle](/docs/database/drizzle): PostgreSQL, MySQL, SQLite
* [Prisma](/docs/database/prisma): `@prisma/client`
* [MongoDB](/docs/database/mongodb): native driver collections
* [Schema](/docs/database/schema): canonical tables and indexes
* [Triggers](/docs/database/triggers): composing `onComplete` and `getCallbackUrl`
* [Hooks](/docs/database/hooks): cache invalidation, identity resolution, trigger authorization
Examples [#examples]
Runnable Next.js examples for each database adapter live in the [examples repository](https://github.com/integratedotdev/examples):
| Adapter | Example |
| ------- | ------------------------------------------------------------------------------------------------------------ |
| Drizzle | [`database/drizzle-example`](https://github.com/integratedotdev/examples/tree/main/database/drizzle-example) |
| Prisma | [`database/prisma-example`](https://github.com/integratedotdev/examples/tree/main/database/prisma-example) |
| MongoDB | [`database/mongodb-example`](https://github.com/integratedotdev/examples/tree/main/database/mongodb-example) |
Each example connects GitHub OAuth, persists tokens with the adapter, and lists repositories from the browser.
What stays app-specific [#what-stays-app-specific]
`getSessionContext` cannot be fully abstracted. Each app wires its auth library or internal service headers. Optional [hooks](/docs/database/hooks) cover app-specific behavior (cache revalidation, GitHub email resolution, trigger ownership repair) without forking the adapter.
Next steps [#next-steps]
* [OAuth authorization](/docs/getting-started/basic-usage)
* [Triggers (getting started)](/docs/getting-started/triggers)
* [Built-in Integrations](/docs/integrations)
# MongoDB
The MongoDB adapter stores documents in configurable collections with string `id` fields (no `ObjectId` requirement).
Install [#install]
```bash
bun add integrate-sdk mongodb
```
Collections [#collections]
Default collection names:
| Collection | Purpose |
| ----------------- | ------------------ |
| `provider_tokens` | OAuth tokens |
| `triggers` | Scheduled triggers |
Documents use a string `id` field as the primary key, plus camelCase fields matching the [canonical schema](/docs/database/schema).
Configuration [#configuration]
```typescript
import { createMCPServer } from "integrate-sdk/server";
import { mongodbAdapter } from "integrate-sdk/adapters/mongodb";
import { MongoClient } from "mongodb";
const client = new MongoClient(process.env.MONGODB_URI!);
const db = client.db("myapp");
export const { client: integrateClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [...],
database: mongodbAdapter(db, {
collectionNames: {
providerTokens: "provider_tokens",
triggers: "triggers",
},
}),
getSessionContext: async (req) => { /* ... */ },
});
```
API [#api]
```typescript
mongodbAdapter(db, {
client?: MongoClient,
collectionNames?: {
providerTokens?: string;
triggers?: string;
},
hooks?: IntegrateAdapterHooks,
debugLogs?: boolean,
})
```
Pass `client` if you need lifecycle management outside the adapter. Triggers are enabled when `collectionNames.triggers` is set (default: `"triggers"`).
Indexes [#indexes]
Create indexes for production workloads:
```javascript
db.provider_tokens.createIndex({ userId: 1, provider: 1 });
db.provider_tokens.createIndex(
{ userId: 1, provider: 1, accountEmail: 1 },
{ unique: true, sparse: true }
);
db.triggers.createIndex({ userId: 1, status: 1 });
db.triggers.createIndex({ nextRunAt: 1 });
```
Example [#example]
See the [MongoDB database example](https://github.com/integratedotdev/examples/tree/main/database/mongodb-example) for a complete Next.js app with GitHub OAuth.
# Prisma
The Prisma adapter uses dynamic model access (`prisma.providerToken.findFirst`, etc.) so you can map custom model names.
Install [#install]
```bash
bun add integrate-sdk @prisma/client
```
Prisma schema [#prisma-schema]
```prisma
model ProviderToken {
id String @id
userId String @map("user_id")
provider String
accountEmail String? @map("account_email")
accountId String? @map("account_id")
accessToken String @map("access_token")
refreshToken String? @map("refresh_token")
tokenType String @default("Bearer") @map("token_type")
expiresAt DateTime? @map("expires_at")
scope String?
createdAt DateTime @default(now()) @map("created_at")
updatedAt DateTime @updatedAt @map("updated_at")
@@unique([userId, provider, accountEmail])
@@map("provider_token")
}
model Trigger {
id String @id
userId String? @map("user_id")
name String?
description String?
toolName String @map("tool_name")
toolArguments Json @map("tool_arguments")
scheduleType String @map("schedule_type")
scheduleValue String @map("schedule_value")
status String @default("active")
provider String?
lastRunAt DateTime? @map("last_run_at")
nextRunAt DateTime? @map("next_run_at")
runCount Int @default(0) @map("run_count")
lastError String? @map("last_error")
lastResult Json? @map("last_result")
createdAt DateTime @default(now()) @map("created_at")
updatedAt DateTime @updatedAt @map("updated_at")
@@map("trigger")
}
```
See [Schema](/docs/database/schema) for field semantics.
Configuration [#configuration]
```typescript
import { createMCPServer } from "integrate-sdk/server";
import { prismaAdapter } from "integrate-sdk/adapters/prisma";
import { prisma } from "./db";
export const { client } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [...],
database: prismaAdapter(prisma, {
provider: "postgresql", // dialect hint for date handling
modelNames: {
providerToken: "providerToken",
trigger: "trigger",
},
}),
getSessionContext: async (req) => { /* ... */ },
});
```
API [#api]
```typescript
prismaAdapter(prisma, {
provider?: "postgresql" | "mysql" | "sqlite",
modelNames?: {
providerToken?: string;
trigger?: string;
},
hooks?: IntegrateAdapterHooks,
debugLogs?: boolean,
})
```
Triggers are enabled when a `trigger` model is configured in `modelNames`.
Example [#example]
See the [Prisma database example](https://github.com/integratedotdev/examples/tree/main/database/prisma-example) for a complete Next.js app with SQLite and GitHub OAuth.
# Schema
Database adapters expect tables (or collections) with these fields. Column names use snake\_case in SQL; Drizzle/Prisma models typically map to camelCase.
provider_token [#provider_token]
Stores OAuth access and refresh tokens per user, provider, and account.
| Column | Type | Notes |
| --------------- | ------------------- | ---------------------------------------------- |
| `id` | text | Primary key |
| `user_id` | text | Owner user |
| `provider` | text | e.g. `github`, `gmail` |
| `account_email` | text, nullable | Identifies account for multi-account providers |
| `account_id` | text, nullable | Provider-specific account id |
| `access_token` | text | Required |
| `refresh_token` | text, nullable | |
| `token_type` | text | Default `Bearer` |
| `expires_at` | timestamp, nullable | |
| `scope` | text, nullable | Space-separated scopes |
| `created_at` | timestamp | |
| `updated_at` | timestamp | |
Indexes [#indexes]
```sql
CREATE INDEX provider_token_user_id_idx ON provider_token(user_id);
CREATE INDEX provider_token_provider_idx ON provider_token(provider);
CREATE INDEX provider_token_user_provider_idx ON provider_token(user_id, provider);
CREATE UNIQUE INDEX provider_token_user_provider_account_email_uidx
ON provider_token(user_id, provider, account_email);
```
The unique index on `(user_id, provider, account_email)` supports multiple accounts per provider. Legacy rows with null `account_email` may coexist until migrated.
Reference Drizzle schema [#reference-drizzle-schema]
Import from the SDK:
```typescript
import { integrateProviderToken } from "integrate-sdk/server";
```
Or copy from `integrate-sdk` source: `src/database/schemas/drizzle.ts`.
trigger [#trigger]
Stores scheduled tool executions.
| Column | Type | Notes |
| ---------------- | -------------------- | ----------------------------------------- |
| `id` | text | Primary key |
| `user_id` | text, nullable | Owner; may be repaired via hooks |
| `name` | text, nullable | |
| `description` | text, nullable | |
| `tool_name` | text | MCP tool to execute |
| `tool_arguments` | json/jsonb | Tool arguments |
| `schedule_type` | text | `once` or `cron` |
| `schedule_value` | text | ISO timestamp (once) or cron expression |
| `status` | text | `active`, `paused`, `completed`, `failed` |
| `provider` | text, nullable | OAuth provider for the tool |
| `last_run_at` | timestamp, nullable | |
| `next_run_at` | timestamp, nullable | |
| `run_count` | integer | Default 0 |
| `last_error` | text, nullable | |
| `last_result` | json/jsonb, nullable | |
| `created_at` | timestamp | |
| `updated_at` | timestamp | |
Indexes [#indexes-1]
```sql
CREATE INDEX trigger_user_id_idx ON trigger(user_id);
CREATE INDEX trigger_status_idx ON trigger(status);
CREATE INDEX trigger_next_run_at_idx ON trigger(next_run_at);
```
ProviderTokenData mapping [#providertokendata-mapping]
When the SDK reads tokens, it returns:
```typescript
interface ProviderTokenData {
accessToken: string;
refreshToken?: string;
tokenType: string;
expiresIn: number;
expiresAt?: string;
scopes?: string[];
email?: string;
accountId?: string;
}
```
The adapter selects the best row when multiple accounts exist (email/accountId hints from context or OAuth flow).
Raw callbacks [#raw-callbacks]
If you do not use an adapter, implement `getProviderToken`, `setProviderToken`, and `removeProviderToken` manually. See the legacy guide content in the [Database overview](/docs/database) and [Triggers](/docs/database/triggers) pages.
# Triggers
When your schema includes a `trigger` table (or MongoDB collection), database adapters register `TriggerCallbacks` for create, get, list, update, and delete. The MCP scheduler calls your app to load triggers and OAuth tokens at execution time.
Adapter + app callbacks [#adapter--app-callbacks]
Merge adapter defaults with app-specific completion logic:
```typescript
import { createMCPServer } from "integrate-sdk/server";
import { drizzleAdapter } from "integrate-sdk/adapters/drizzle";
export const { client } = createMCPServer({
database: drizzleAdapter(db, {
provider: "pg",
schema: { providerToken, trigger },
}),
getSessionContext: async (req) => { /* ... */ },
triggers: {
// Adapter provides create, get, list, update, delete
onComplete: async (context) => {
return handleTriggerCompletion(context);
},
getCallbackUrl: () => process.env.APP_URL!,
},
});
```
Explicit `triggers` fields override adapter callbacks. Only specify what you need beyond CRUD.
onComplete [#oncomplete]
`onComplete` runs after a trigger step finishes. Use it for multi-step workflows, notifications, or updating related app tables. It is **not** part of the database adapter; keep it in your `createMCPServer` config.
getCallbackUrl [#getcallbackurl]
Return the public origin the MCP scheduler should call back into your app (e.g. `https://app.example.com`).
Authorization [#authorization]
By default, trigger get/update/delete enforce `context.userId` matches `trigger.user_id`. For ownership repair (e.g. triggers linked via automation tables), use the [`authorizeTrigger` hook](/docs/database/hooks).
Schedule format [#schedule-format]
The SDK accepts nested schedules on create:
```typescript
{ type: "once", runAt: "2026-06-13T12:00:00.000Z" }
{ type: "cron", expression: "0 9 * * *" }
```
Adapters flatten these to `schedule_type` and `schedule_value` in the database. See [Schema](/docs/database/schema).
Without an adapter [#without-an-adapter]
You can still implement `triggers: { create, get, list, update, delete, onComplete, getCallbackUrl }` manually. See [Getting Started: Triggers](/docs/getting-started/triggers) for the full callback API.
# Anthropic Claude
The Integrate SDK provides seamless integration with Anthropic's Claude API, allowing Claude to access your integrations through MCP tools.
Installation [#installation]
Install the Integrate SDK and Anthropic SDK packages:
```bash
bun add integrate-sdk @anthropic-ai/sdk
```
Setup [#setup]
Setting up Anthropic integration requires **3 files** (or **5 files** if not using a database):
1. Server Configuration [#1-server-configuration]
Create a server configuration file with your OAuth credentials:
```typescript
// lib/integrate.ts
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
```
2. Providers (only if no database) [#2-providers-only-if-no-database]
If you're not using a database, create a providers component that injects tokens:
```typescript
// app/providers.tsx
"use client";
import { client } from "integrate-sdk";
import { useIntegrateAI } from "integrate-sdk/react";
export function Providers({ children }: { children: React.ReactNode }) {
useIntegrateAI(client);
return <>{children}>;
}
```
3. Layout (only if no database) [#3-layout-only-if-no-database]
Wrap your app with the Providers component:
```typescript
// app/layout.tsx
import { Providers } from "./providers";
export default function RootLayout({
children,
}: Readonly<{
children: React.ReactNode;
}>) {
return (
{children}
);
}
```
4. OAuth Handler [#4-oauth-handler]
Create a catch-all route that handles OAuth operations at `app/api/integrate/[...all]/route.ts`:
```typescript
import { serverClient } from "@/lib/integrate";
import { toNextJsHandler } from "integrate-sdk/server";
export const { POST, GET } = toNextJsHandler(serverClient);
```
5. Chat API Route [#5-chat-api-route]
Create a chat route that converts MCP tools to Anthropic format:
```typescript
// app/api/chat/route.ts
import { serverClient } from "@/lib/integrate";
import { getAnthropicTools } from "integrate-sdk/server";
import Anthropic from "@anthropic-ai/sdk";
import { handleAnthropicMessage } from "integrate-sdk/ai/anthropic";
const anthropic = new Anthropic();
export async function POST(req: Request) {
const { messages } = await req.json();
const msg = await anthropic.messages.create({
model: "claude-sonnet-4-5",
messages,
tools: await getAnthropicTools(serverClient),
max_tokens: 1000,
});
const result = await handleAnthropicMessage(serverClient, msg);
return Response.json(result);
}
```
Usage [#usage]
Use Anthropic's Claude in any component:
```typescript
// app/page.tsx
"use client";
import { useState, useEffect } from "react";
import { client } from "integrate-sdk";
import Anthropic from "@anthropic-ai/sdk";
import { Streamdown } from "streamdown";
export default function ChatPage() {
const [messages, setMessages] = useState([]);
const [input, setInput] = useState("");
const [loading, setLoading] = useState(false);
const [githubAuthorized, setGithubAuthorized] = useState(false);
useEffect(() => {
client.isAuthorized("github").then(setGithubAuthorized);
}, []);
async function handleGithubClick() {
try {
if (githubAuthorized) {
await client.disconnectProvider("github");
} else {
await client.authorize("github");
}
setGithubAuthorized(client.isAuthorized("github"));
} catch (error) {
console.error("Error:", error);
}
}
async function handleSubmit(e: React.FormEvent) {
e.preventDefault();
if (!input.trim()) return;
const userMessage: Anthropic.MessageParam = {
role: "user",
content: input,
};
setMessages((prev) => [...prev, userMessage]);
setInput("");
setLoading(true);
try {
const response = await fetch("/api/chat", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
messages: [...messages, userMessage],
}),
});
const data = await response.json();
const newMessages = Array.isArray(data) ? data : [data];
setMessages((prev) => [
...prev,
...newMessages.map((msg: Anthropic.MessageParam) => ({
role: msg.role,
content: msg.content,
})),
]);
} catch (error) {
console.error("Error:", error);
} finally {
setLoading(false);
}
}
const renderContent = (
content: Anthropic.MessageParam["content"],
isAssistant: boolean
) => {
if (typeof content === "string") {
if (isAssistant) {
return {content};
}
return
{content}
;
}
if (Array.isArray(content)) {
return (
{content.map((block, index) => {
if (block.type === "text") {
if (isAssistant) {
return (
{block.text}
);
}
return (
{block.text}
);
}
if (block.type === "tool_use") {
return null;
}
if (block.type === "tool_result") {
let displayContent = block.content;
if (typeof block.content === "string") {
try {
const parsed = JSON.parse(block.content);
if (parsed.content && Array.isArray(parsed.content)) {
return (
);
}
```
Next Steps [#next-steps]
* Explore [Advanced Configuration](/docs/getting-started/advanced-usage)
* Check the [API Reference](/docs/reference/options) for complete type definitions
# Code Mode
Code Mode is the default way the Integrate SDK exposes your integrations to AI models. Instead of sending every MCP tool (potentially hundreds across 25+ integrations) to the model on each request, Code Mode hands the LLM a single `execute_code` tool and a typed TypeScript API it can write code against.
The LLM writes a snippet, the snippet runs in an isolated [Vercel Sandbox](https://vercel.com/docs/vercel-sandbox), and the results come back in one round-trip, no matter how many integrations the code touches.
Why Code Mode [#why-code-mode]
| | Per-tool (legacy) | Code Mode |
| -------------------------------- | ----------------------------------- | -------------------------------- |
| Tools sent to model | 1 per MCP tool (25+ Γ N) | 1 (`execute_code`) |
| Round-trips for multi-step tasks | 1 per tool call | 1 for the whole snippet |
| Context window pressure | High (full tool list every request) | Low (typed API surface only) |
| Model strength | Structured tool-calling | Writing code (what LLMs do best) |
Requirements [#requirements]
Install the sandbox peer dependency:
```bash
bun add @vercel/sandbox
```
Code Mode needs a publicly reachable URL for your app so the sandbox can call back into your `/api/integrate/mcp` route. Set this in your server config:
```typescript
// lib/integrate.ts
import { createMCPServer, githubIntegration, gmailIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({ scopes: ["repo", "user"] }),
gmailIntegration({ scopes: ["gmail.send", "gmail.readonly"] }),
],
codeMode: {
publicUrl: process.env.INTEGRATE_URL, // e.g. "https://myapp.com"
},
});
```
Or set the environment variable directly (no config change needed):
```bash
INTEGRATE_URL=https://myapp.com
```
Code Mode will return a clear error if `publicUrl` is not set. The sandbox needs it to call back into your `/api/integrate/mcp` route. On the server, set `codeMode.publicUrl` in `createMCPServer` or export `INTEGRATE_URL`. Auto-detection uses either value.
Scoping tools to connected integrations [#scoping-tools-to-connected-integrations]
Code Mode reduces tools sent to the model, but discovery can still fetch every configured integration on cold start. Pass `connectedOnly` with a user context so only OAuth-connected integrations are loaded:
```typescript
const tools = await getVercelAITools(serverClient, {
context: { userId: session.user.id },
connectedOnly: true,
mode: "code",
});
```
See [MCP Tool Scoping](/docs/guides/mcp-tool-scoping) and [Performance](/docs/guides/performance).
Usage [#usage]
No API changes are required. `getVercelAITools`, `getOpenAITools`, `getAnthropicTools`, and `getGoogleTools` all default to Code Mode automatically.
Vercel AI SDK [#vercel-ai-sdk]
```typescript
// app/api/chat/route.ts
import { serverClient } from "@/lib/integrate";
import { getVercelAITools } from "integrate-sdk/server";
import { convertToModelMessages, stepCountIs, streamText } from "ai";
export async function POST(req: Request) {
const { messages } = await req.json();
const result = streamText({
model: "openai/gpt-4o",
messages: convertToModelMessages(messages),
tools: await getVercelAITools(serverClient), // Code Mode is the default
stopWhen: stepCountIs(3),
});
return result.toUIMessageStreamResponse();
}
```
OpenAI [#openai]
```typescript
// app/api/chat/route.ts
import { serverClient } from "@/lib/integrate";
import { getOpenAITools, handleOpenAIResponse } from "integrate-sdk/server";
import OpenAI from "openai";
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
export async function POST(req: Request) {
const { messages } = await req.json();
const response = await openai.responses.create({
model: "gpt-4o",
input: messages,
tools: await getOpenAITools(serverClient), // Code Mode is the default
});
const result = await handleOpenAIResponse(serverClient, response);
return Response.json(result);
}
```
Anthropic [#anthropic]
```typescript
// app/api/chat/route.ts
import { serverClient } from "@/lib/integrate";
import { getAnthropicTools, handleAnthropicMessage } from "integrate-sdk/server";
import Anthropic from "@anthropic-ai/sdk";
const anthropic = new Anthropic();
export async function POST(req: Request) {
const { messages } = await req.json();
const msg = await anthropic.messages.create({
model: "claude-sonnet-4-5",
messages,
tools: await getAnthropicTools(serverClient), // Code Mode is the default
max_tokens: 4096,
});
const result = await handleAnthropicMessage(serverClient, msg);
return Response.json(result);
}
```
Google GenAI [#google-genai]
```typescript
// app/api/chat/route.ts
import { serverClient } from "@/lib/integrate";
import { getGoogleTools, executeGoogleFunctionCalls } from "integrate-sdk/server";
import { GoogleGenAI } from "@google/genai";
const ai = new GoogleGenAI({ apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY });
export async function POST(req: Request) {
const { messages } = await req.json();
const response = await ai.models.generateContent({
model: "gemini-2.0-flash-001",
contents: messages,
config: {
tools: [{ functionDeclarations: await getGoogleTools(serverClient) }], // Code Mode is the default
},
});
if (response.functionCalls?.length) {
const results = await executeGoogleFunctionCalls(serverClient, response.functionCalls);
return Response.json(results);
}
return Response.json(response);
}
```
What the LLM sees [#what-the-llm-sees]
When Code Mode is active, the model receives a single `execute_code` tool whose description contains a generated TypeScript API derived from your enabled integrations:
```typescript
export interface GithubClient {
/** Create a new issue in a repository */
createIssue(args: {
/** Repository owner */
owner: string;
repo: string;
title: string;
body?: string;
labels?: string[];
}): Promise;
/** List repositories for the authenticated user */
listRepos(args?: { visibility?: "all" | "public" | "private" }): Promise;
}
export interface GmailClient {
/** Send an email */
sendMessage(args: {
to: string;
subject: string;
body: string;
}): Promise;
}
export interface Client {
github: GithubClient;
gmail: GmailClient;
}
export declare const client: Client;
```
The model writes code against this surface. A multi-step task that would have required multiple round-trips with per-tool mode is handled in one:
```typescript
// What the LLM writes inside execute_code:
const issues = await client.github.listIssues({ owner: "acme", repo: "api" });
const open = JSON.parse(issues.content[0].text).filter((i: any) => i.state === "open");
for (const issue of open.slice(0, 3)) {
await client.gmail.sendMessage({
to: "team@acme.com",
subject: `Open issue: ${issue.title}`,
body: `#${issue.number} - ${issue.html_url}`,
});
}
return { notified: open.slice(0, 3).map((i: any) => i.number) };
```
Advanced configuration [#advanced-configuration]
```typescript
createMCPServer({
// ...
codeMode: {
publicUrl: process.env.INTEGRATE_URL,
runtime: "node24", // "node22" (default) or "node24"
timeoutMs: 30_000, // sandbox timeout, default 60_000
vcpus: 1, // default 2
},
});
```
Opting out [#opting-out]
If you need the legacy behavior (one tool per MCP tool), pass `mode: 'tools'` to any helper:
```typescript
// One tool per integration method. Useful if your model doesn't handle code well.
const tools = await getVercelAITools(serverClient, { mode: "tools" });
const tools = await getOpenAITools(serverClient, { mode: "tools" });
const tools = await getAnthropicTools(serverClient, { mode: "tools" });
const tools = await getGoogleTools(serverClient, { mode: "tools" });
```
Authentication [#authentication]
OAuth works exactly as before. The user authenticates once via the standard OAuth popup, and their tokens are automatically forwarded through the sandbox to every tool call the LLM code makes. No changes to your auth setup are required.
# Google GenAI
The Integrate SDK provides seamless integration with Google's Generative AI SDK (Gemini), allowing AI models to access your integrations through MCP tools.
Installation [#installation]
Install the Integrate SDK and Google GenAI packages:
```bash
bun add integrate-sdk @google/generative-ai
```
Setup [#setup]
Setting up Google GenAI integration requires **3 files** (or **5 files** if not using a database):
1. Server Configuration [#1-server-configuration]
Create a server configuration file with your OAuth credentials:
```typescript
// lib/integrate.ts
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
```
2. Providers (only if no database) [#2-providers-only-if-no-database]
If you're not using a database, create a providers component that injects tokens:
```typescript
// app/providers.tsx
"use client";
import { client } from "integrate-sdk";
import { useIntegrateAI } from "integrate-sdk/react";
export function Providers({ children }: { children: React.ReactNode }) {
useIntegrateAI(client);
return <>{children}>;
}
```
3. Layout (only if no database) [#3-layout-only-if-no-database]
Wrap your app with the Providers component:
```typescript
// app/layout.tsx
import { Providers } from "./providers";
export default function RootLayout({
children,
}: Readonly<{
children: React.ReactNode;
}>) {
return (
{children}
);
}
```
4. OAuth Handler [#4-oauth-handler]
Create a catch-all route that handles OAuth operations at `app/api/integrate/[...all]/route.ts`:
```typescript
import { serverClient } from "@/lib/integrate";
import { toNextJsHandler } from "integrate-sdk/server";
export const { POST, GET } = toNextJsHandler(serverClient);
```
5. Chat API Route [#5-chat-api-route]
Create a chat route that converts MCP tools to Google GenAI format:
```typescript
// app/api/chat/route.ts
import { serverClient } from "@/lib/integrate";
import { GoogleGenAI } from "@google/genai";
import {
executeGoogleFunctionCalls,
getGoogleTools,
} from "integrate-sdk/server";
const ai = new GoogleGenAI({
apiKey: process.env.GOOGLE_GENERATIVE_AI_API_KEY,
});
export async function POST(req: Request) {
const { messages } = await req.json();
const response = await ai.models.generateContent({
model: "gemini-2.0-flash-001",
contents: messages,
config: {
tools: [{ functionDeclarations: await getGoogleTools(serverClient) }],
},
});
if (response.functionCalls && response.functionCalls.length > 0) {
const results = await executeGoogleFunctionCalls(
serverClient,
response.functionCalls
);
return Response.json(results);
}
return Response.json(response);
}
```
Usage [#usage]
Use Google GenAI in any component:
```typescript
// app/page.tsx
"use client";
import { useState, useEffect } from "react";
import { client } from "integrate-sdk";
import { Streamdown } from "streamdown";
interface Message {
role: "user" | "assistant";
content: string;
}
export default function ChatPage() {
const [messages, setMessages] = useState([]);
const [input, setInput] = useState("");
const [loading, setLoading] = useState(false);
const [githubAuthorized, setGithubAuthorized] = useState(false);
const isLoading = loading;
useEffect(() => {
client.isAuthorized("github").then(setGithubAuthorized);
}, []);
async function handleGithubClick() {
try {
if (githubAuthorized) {
await client.disconnectProvider("github");
} else {
await client.authorize("github");
}
setGithubAuthorized(client.isAuthorized("github"));
} catch (error) {
console.error("Error:", error);
}
}
function formatFunctionOutput(output: unknown): string {
try {
const data = typeof output === "string" ? JSON.parse(output) : output;
if (data.structuredContent?.repositories) {
let displayText = "\n\nπ¦ **GitHub Repositories:**\n\n";
for (const repo of data.structuredContent.repositories) {
displayText += `**${repo.name}**\n`;
displayText += `${repo.html_url}\n`;
if (repo.description) {
displayText += `_${repo.description}_\n`;
}
displayText += `Language: ${repo.language || "N/A"} β’ Stars: ${
repo.stargazers_count
} β’ ${repo.private ? "Private" : "Public"}\n\n`;
}
return displayText;
}
if (data.content && Array.isArray(data.content)) {
let text = "";
for (const item of data.content) {
if (item.type === "text" && item.text) {
try {
const parsed = JSON.parse(item.text);
if (parsed.repositories) {
let repoText = "\n\nπ¦ **GitHub Repositories:**\n\n";
for (const repo of parsed.repositories) {
repoText += `**${repo.name}**\n`;
repoText += `${repo.html_url}\n`;
if (repo.description) {
repoText += `_${repo.description}_\n`;
}
repoText += `Language: ${repo.language || "N/A"} β’ Stars: ${
repo.stargazers_count
} β’ ${repo.private ? "Private" : "Public"}\n\n`;
}
text += repoText;
} else {
text += JSON.stringify(parsed, null, 2);
}
} catch {
text += item.text;
}
}
}
return text;
}
return JSON.stringify(data, null, 2);
} catch (e) {
console.error("Error formatting function output:", e);
return String(output);
}
}
async function handleSubmit(e: React.FormEvent) {
e.preventDefault();
if (!input.trim()) return;
const userMessage: Message = { role: "user", content: input };
setMessages((prev) => [...prev, userMessage]);
setInput("");
setLoading(true);
try {
const googleMessages = [...messages, userMessage].map((msg) => ({
role: msg.role === "assistant" ? "model" : "user",
parts: [{ text: msg.content }],
}));
const response = await fetch("/api/chat", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
messages: googleMessages,
}),
});
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
const result = await response.json();
let assistantContent = "";
if (result.structuredContent) {
assistantContent = formatFunctionOutput(result);
} else if (result.text) {
assistantContent = result.text;
} else if (result.candidates && result.candidates[0]?.content) {
const content = result.candidates[0].content;
if (content.parts) {
for (const part of content.parts) {
if (part.text) {
assistantContent += part.text;
}
}
}
} else if (Array.isArray(result)) {
for (const item of result) {
if (typeof item === "string") {
try {
const parsed = JSON.parse(item);
if (parsed.structuredContent) {
assistantContent += formatFunctionOutput(parsed);
} else {
assistantContent += item;
}
} catch {
assistantContent += item;
}
} else if (item.structuredContent) {
assistantContent += formatFunctionOutput(item);
} else if (item.type === "function_call_output") {
assistantContent += formatFunctionOutput(item.output);
} else if (item.content && Array.isArray(item.content)) {
for (const contentItem of item.content) {
if (contentItem.text) {
assistantContent += formatFunctionOutput(contentItem.text);
}
}
}
}
}
if (!assistantContent.trim()) {
assistantContent =
"Response received but no displayable content found.";
}
setMessages((prev) => [
...prev,
{ role: "assistant", content: assistantContent.trim() },
]);
} catch (error) {
console.error("Error:", error);
setMessages((prev) => [
...prev,
{
role: "assistant",
content: `Error: ${
error instanceof Error ? error.message : "Unknown error"
}`,
},
]);
} finally {
setLoading(false);
}
}
return (
{messages.map((m, i) => (
{m.content}
))}
);
}
```
Next Steps [#next-steps]
* Explore [Advanced Configuration](/docs/getting-started/advanced-usage)
* Check the [API Reference](/docs/reference/options) for complete type definitions
# OpenAI
The Integrate SDK provides seamless integration with OpenAI's Responses API, allowing AI models to access your integrations through MCP tools.
Installation [#installation]
Install the Integrate SDK and OpenAI SDK packages:
```bash
bun add integrate-sdk openai
```
Setup [#setup]
Setting up OpenAI integration requires **3 files** (or **5 files** if not using a database):
1. Server Configuration [#1-server-configuration]
Create a server configuration file with your OAuth credentials:
```typescript
// lib/integrate.ts
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
```
2. Providers (only if no database) [#2-providers-only-if-no-database]
If you're not using a database, create a providers component that injects tokens:
```typescript
// app/providers.tsx
"use client";
import { client } from "integrate-sdk";
import { useIntegrateAI } from "integrate-sdk/react";
export function Providers({ children }: { children: React.ReactNode }) {
useIntegrateAI(client);
return <>{children}>;
}
```
3. Layout (only if no database) [#3-layout-only-if-no-database]
Wrap your app with the Providers component:
```typescript
// app/layout.tsx
import { Providers } from "./providers";
export default function RootLayout({
children,
}: Readonly<{
children: React.ReactNode;
}>) {
return (
{children}
);
}
```
4. OAuth Handler [#4-oauth-handler]
Create a catch-all route that handles OAuth operations at `app/api/integrate/[...all]/route.ts`:
```typescript
import { serverClient } from "@/lib/integrate";
import { toNextJsHandler } from "integrate-sdk/server";
export const { POST, GET } = toNextJsHandler(serverClient);
```
5. Chat API Route [#5-chat-api-route]
Create a chat route that converts MCP tools to OpenAI format:
```typescript
// app/api/chat/route.ts
import { serverClient } from "@/lib/integrate";
import { getOpenAITools, handleOpenAIResponse } from "integrate-sdk/server";
import OpenAI from "openai";
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
export async function POST(req: Request) {
const { messages } = await req.json();
const response = await openai.responses.create({
model: "gpt-5-nano",
input: messages,
tools: await getOpenAITools(serverClient),
});
const result = await handleOpenAIResponse(serverClient, response);
return Response.json(result);
}
```
Usage [#usage]
Use OpenAI's API in any component:
```typescript
// app/page.tsx
"use client";
import { useState, useEffect } from "react";
import { client } from "integrate-sdk";
import { Streamdown } from "streamdown";
interface Message {
role: "user" | "assistant";
content: string;
}
export default function ChatPage() {
const [messages, setMessages] = useState([]);
const [input, setInput] = useState("");
const [loading, setLoading] = useState(false);
const [githubAuthorized, setGithubAuthorized] = useState(false);
const isLoading = loading;
useEffect(() => {
client.isAuthorized("github").then(setGithubAuthorized);
}, []);
async function handleGithubClick() {
try {
if (githubAuthorized) {
await client.disconnectProvider("github");
} else {
await client.authorize("github");
}
setGithubAuthorized(client.isAuthorized("github"));
} catch (error) {
console.error("Error:", error);
}
}
function formatFunctionOutput(output: unknown): string {
try {
const data = typeof output === "string" ? JSON.parse(output) : output;
if (data.structuredContent?.repositories) {
let displayText = "\n\nπ¦ **GitHub Repositories:**\n\n";
for (const repo of data.structuredContent.repositories) {
displayText += `**${repo.name}**\n`;
displayText += `${repo.html_url}\n`;
if (repo.description) {
displayText += `_${repo.description}_\n`;
}
displayText += `Language: ${repo.language || "N/A"} β’ Stars: ${
repo.stargazers_count
} β’ ${repo.private ? "Private" : "Public"}\n\n`;
}
return displayText;
}
if (data.content && Array.isArray(data.content)) {
let text = "";
for (const item of data.content) {
if (item.type === "text" && item.text) {
try {
const parsed = JSON.parse(item.text);
if (parsed.repositories) {
let repoText = "\n\nπ¦ **GitHub Repositories:**\n\n";
for (const repo of parsed.repositories) {
repoText += `**${repo.name}**\n`;
repoText += `${repo.html_url}\n`;
if (repo.description) {
repoText += `_${repo.description}_\n`;
}
repoText += `Language: ${repo.language || "N/A"} β’ Stars: ${
repo.stargazers_count
} β’ ${repo.private ? "Private" : "Public"}\n\n`;
}
text += repoText;
} else {
text += JSON.stringify(parsed, null, 2);
}
} catch {
text += item.text;
}
}
}
return text;
}
return JSON.stringify(data, null, 2);
} catch (e) {
console.error("Error formatting function output:", e);
return String(output);
}
}
async function handleSubmit(e: React.FormEvent) {
e.preventDefault();
if (!input.trim()) return;
const userMessage: Message = { role: "user", content: input };
setMessages((prev) => [...prev, userMessage]);
setInput("");
setLoading(true);
try {
const response = await fetch("/api/chat", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
messages: [...messages, userMessage],
}),
});
if (!response.ok) {
throw new Error(`HTTP error! status: ${response.status}`);
}
const result = await response.json();
let assistantContent = "";
const outputArray = Array.isArray(result) ? result : result.output;
if (outputArray && Array.isArray(outputArray)) {
for (const item of outputArray) {
if (item.type === "message" && item.content) {
for (const content of item.content) {
if (content.type === "text" || content.type === "output_text") {
assistantContent += content.text + "\n";
}
}
} else if (item.type === "function_call") {
assistantContent += `π§ Called function: ${item.name}\n`;
} else if (item.type === "function_call_output") {
assistantContent += formatFunctionOutput(item.output);
}
}
}
if (!assistantContent.trim()) {
assistantContent =
"Response received but no displayable content found.";
}
setMessages((prev) => [
...prev,
{ role: "assistant", content: assistantContent.trim() },
]);
} catch (error) {
console.error("Error:", error);
setMessages((prev) => [
...prev,
{
role: "assistant",
content: `Error: ${
error instanceof Error ? error.message : "Unknown error"
}`,
},
]);
} finally {
setLoading(false);
}
}
return (
{messages.map((m, i) => (
{m.content}
))}
);
}
```
Next Steps [#next-steps]
* Explore [Advanced Configuration](/docs/getting-started/advanced-usage)
* Check the [API Reference](/docs/reference/options) for complete type definitions
# Vercel AI SDK
The Integrate SDK provides seamless integration with Vercel's AI SDK, allowing AI models to access your integrations through MCP tools.
Installation [#installation]
Install the Integrate SDK and Vercel AI SDK packages:
```bash
bun add integrate-sdk ai @ai-sdk/react
```
Setup [#setup]
Setting up Vercel AI integration requires **3 files** (or **5 files** if not using a database):
1. Server Configuration [#1-server-configuration]
Create a server configuration file with your OAuth credentials:
```typescript
// lib/integrate.ts
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
```
2. Providers (only if no database) [#2-providers-only-if-no-database]
If you're not using a database, create a providers component that injects tokens:
```typescript
// app/providers.tsx
"use client";
import { client } from "integrate-sdk";
import { useIntegrateAI } from "integrate-sdk/react";
export function Providers({ children }: { children: React.ReactNode }) {
useIntegrateAI(client);
return <>{children}>;
}
```
3. Layout (only if no database) [#3-layout-only-if-no-database]
Wrap your app with the Providers component:
```typescript
// app/layout.tsx
import { Providers } from "./providers";
export default function RootLayout({
children,
}: Readonly<{
children: React.ReactNode;
}>) {
return (
{children}
);
}
```
4. OAuth Handler [#4-oauth-handler]
Create a catch-all route that handles OAuth operations at `app/api/integrate/[...all]/route.ts`:
```typescript
import { serverClient } from "@/lib/integrate";
import { toNextJsHandler } from "integrate-sdk/server";
export const { POST, GET } = toNextJsHandler(serverClient);
```
5. Chat API Route [#5-chat-api-route]
Create a chat route that converts MCP tools to Vercel AI format:
```typescript
// app/api/chat/route.ts
import { serverClient } from "@/lib/integrate";
import { getVercelAITools } from "integrate-sdk/server";
import { convertToModelMessages, stepCountIs, streamText } from "ai";
export async function POST(req: Request) {
const { messages } = await req.json();
const result = streamText({
model: "openai/gpt-5-mini",
messages: convertToModelMessages(messages),
tools: await getVercelAITools(serverClient),
stopWhen: stepCountIs(5),
});
return result.toUIMessageStreamResponse();
}
```
Usage [#usage]
Use the Vercel AI SDK's `useChat` hook in any component:
```typescript
// app/page.tsx
"use client";
import { useChat } from "@ai-sdk/react";
import { Streamdown } from "streamdown";
import { useState, useEffect } from "react";
import { client } from "integrate-sdk";
export default function ChatPage() {
const { messages, sendMessage, status } = useChat();
const [input, setInput] = useState("");
const [githubAuthorized, setGithubAuthorized] = useState(false);
const isLoading = status === "streaming";
useEffect(() => {
client.isAuthorized("github").then(setGithubAuthorized);
}, []);
async function handleGithubClick() {
try {
if (githubAuthorized) {
await client.disconnectProvider("github");
} else {
await client.authorize("github");
}
setGithubAuthorized(client.isAuthorized("github"));
} catch (error) {
console.error("Error:", error);
}
}
return (
{messages.map((message) => (
{message.parts
.filter((part) => part.type === "text")
.map((part) => ("text" in part ? part.text : ""))
.join("")}
))}
);
}
```
Next Steps [#next-steps]
* Explore [Advanced Configuration](/docs/getting-started/advanced-usage)
* Check the [API Reference](/docs/reference/options) for complete type definitions
# Advanced Usage
This guide covers advanced configuration options for power users who need custom client configuration and fine-grained control over connection behavior, OAuth flows, error handling, and more.
Custom Client Configuration [#custom-client-configuration]
For advanced use cases, you can create a custom configured client instead of using the default client:
```typescript
// lib/integrate-client.ts
import { createMCPClient, githubIntegration } from "integrate-sdk";
export const client = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
```
Then import and use your custom client:
```typescript
import { client } from "@/lib/integrate-client";
await client.authorize("github");
```
Connection Modes [#connection-modes]
Control when and how the client connects to the MCP server.
```typescript
import { createMCPClient, githubIntegration } from "integrate-sdk";
const client = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
connectionMode: "lazy",
});
await client.github.listOwnRepos({});
const eagerClient = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
connectionMode: "eager",
});
const manualClient = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
connectionMode: "manual",
});
await manualClient.connect();
await manualClient.github.listOwnRepos({});
await manualClient.disconnect();
```
When to Use Each Mode [#when-to-use-each-mode]
* **lazy** (default): Best for most use cases - connects automatically when needed
* **eager**: When you want to pre-connect and cache the connection, or validate credentials early
* **manual**: When you need precise control over connection lifecycle (testing, connection pooling)
Singleton Pattern [#singleton-pattern]
By default, `createMCPClient` returns cached instances to improve performance and reduce connections.
```typescript
import { createMCPClient, githubIntegration } from "integrate-sdk";
const client1 = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
singleton: true,
});
const client2 = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
singleton: true,
});
const uniqueClient = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
singleton: false,
});
```
Clearing the Cache [#clearing-the-cache]
```typescript
import { clearClientCache } from "integrate-sdk";
// Clear all cached clients and disconnect them
await clearClientCache();
```
Multi-Account Support [#multi-account-support]
Connect and manage multiple accounts from the same OAuth provider (for example, multiple GitHub or Gmail accounts).
Listing Connected Accounts [#listing-connected-accounts]
```typescript
const accounts = await client.listAccounts("github");
// [
// { email: "work@example.com", accountId: "github_abc123", ... },
// { email: "personal@gmail.com", accountId: "github_def456", ... }
// ]
```
Checking Authorization for Specific Account [#checking-authorization-for-specific-account]
```typescript
// Check if any account is authorized
const hasAny = await client.isAuthorized("github");
// Check if a specific account is authorized
const hasWork = await client.isAuthorized("github", "work@example.com");
```
Disconnecting a Specific Account [#disconnecting-a-specific-account]
```typescript
// Disconnect a specific account by email
await client.disconnectAccount("github", "work@example.com");
// Disconnect all accounts for a provider
await client.disconnectProvider("github");
```
Setting Token for a Specific Account [#setting-token-for-a-specific-account]
```typescript
client.setProviderToken(
"github",
{
accessToken: "ghp_...",
tokenType: "Bearer",
expiresIn: 3600,
},
"work@example.com"
);
```
Auto-Cleanup [#auto-cleanup]
Control whether clients automatically disconnect on process exit.
```typescript
import { createMCPClient, githubIntegration } from "integrate-sdk";
const client = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
autoCleanup: true,
});
const manualClient = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
autoCleanup: false,
});
await manualClient.disconnect();
```
Re-Authentication Handling [#re-authentication-handling]
Handle expired or invalid OAuth tokens automatically.
```typescript
import { createMCPClient, githubIntegration } from "integrate-sdk";
const client = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
onReauthRequired: async (context) => {
console.log(`Re-auth needed for ${context.provider}`);
console.log(`Error: ${context.error.message}`);
console.log(`Tool: ${context.toolName}`);
try {
await client.authorize(context.provider);
return true;
} catch (error) {
console.error("Re-auth failed:", error);
return false;
}
},
maxReauthRetries: 1,
});
try {
await client.github.createIssue({
owner: "owner",
repo: "repo",
title: "Test issue",
});
} catch (error) {
console.error("Failed:", error);
}
```
OAuth Flow Configuration [#oauth-flow-configuration]
Customize the OAuth authorization experience.
```typescript
import { createMCPClient, githubIntegration } from "integrate-sdk";
const client = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
oauthFlow: {
mode: "popup",
popupOptions: {
width: 600,
height: 700,
},
onAuthCallback: async (provider, code, state) => {
console.log(`Received callback for ${provider}`);
},
},
});
```
Popup vs Redirect [#popup-vs-redirect]
**Popup Mode:**
* Opens OAuth in a new window
* User stays on current page
* Better for single-page apps
* Blocked by some browsers
**Redirect Mode (default):**
* Full page redirect to OAuth provider
* More reliable, works everywhere
* Preserves URL with `returnUrl`
OAuth Configuration [#oauth-configuration]
Fine-tune OAuth behavior and URLs.
```typescript
import { createMCPClient, githubIntegration } from "integrate-sdk";
const client = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
oauthApiBase: "/api/integrate/oauth",
redirectUri: "https://myapp.com/api/integrate/oauth/callback",
autoHandleOAuthCallback: true,
sessionToken: "existing-session-token",
});
```
OAuth Redirect URI Auto-Detection [#oauth-redirect-uri-auto-detection]
**Client-side:**
```typescript
import { createMCPClient, githubIntegration } from "integrate-sdk";
const client = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
```
**Server-side:**
```typescript
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
const { client } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
clientId: process.env.GITHUB_CLIENT_ID,
clientSecret: process.env.GITHUB_CLIENT_SECRET,
scopes: ["repo", "user"],
}),
],
});
const { client: explicitClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
clientId: process.env.GITHUB_CLIENT_ID,
clientSecret: process.env.GITHUB_CLIENT_SECRET,
scopes: ["repo", "user"],
}),
],
redirectUri: process.env.OAUTH_REDIRECT_URI,
});
```
Client Information [#client-information]
Customize the client identity sent to the MCP server.
```typescript
import { createMCPClient, githubIntegration } from "integrate-sdk";
const client = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
clientInfo: {
name: "my-app",
version: "1.2.3",
},
});
```
HTTP Configuration [#http-configuration]
Configure HTTP transport settings.
```typescript
import { createMCPClient, githubIntegration } from "integrate-sdk";
const client = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
headers: {
"X-Custom-Header": "value",
"X-App-Version": "1.0.0",
},
timeout: 60000,
});
```
Server-Side Configuration [#server-side-configuration]
`createMCPServer` supports the same options as `createMCPClient`, plus server-specific features.
```typescript
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
export const { client, POST, GET } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
clientId: process.env.GITHUB_CLIENT_ID,
clientSecret: process.env.GITHUB_CLIENT_SECRET,
scopes: ["repo", "user"],
}),
],
connectionMode: "lazy",
singleton: true,
autoCleanup: true,
timeout: 30000,
redirectUri: process.env.OAUTH_REDIRECT_URI,
});
export { POST, GET };
```
Event Listeners [#event-listeners]
Listen to OAuth events for custom logic.
```typescript
import { createMCPClient, githubIntegration } from "integrate-sdk";
const client = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
client.on("auth:started", ({ provider }) => {
console.log(`Starting OAuth for ${provider}`);
});
client.on("auth:complete", ({ provider, accessToken, expiresAt }) => {
console.log(`${provider} authorized until ${expiresAt}`);
});
client.on("auth:error", ({ provider, error }) => {
console.error(`Auth error for ${provider}:`, error.message);
});
client.on("auth:disconnect", ({ provider }) => {
console.log(`${provider} disconnected`);
});
client.on("auth:logout", () => {
console.log("User logged out from all services");
});
const handler = ({ provider }) => console.log(provider);
client.on("auth:complete", handler);
client.off("auth:complete", handler);
```
Provider Token Management [#provider-token-management]
Work with provider tokens directly.
```typescript
import { createMCPClient, githubIntegration } from "integrate-sdk";
const client = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
const githubToken = client.getProviderToken("github");
console.log(githubToken.accessToken);
console.log(githubToken.expiresAt);
client.setProviderToken("github", {
accessToken: "ghp_...",
tokenType: "Bearer",
expiresIn: 3600,
});
const allTokens = client.getAllProviderTokens();
await fetch("/api/ai", {
method: "POST",
headers: {
"x-integrate-tokens": JSON.stringify(allTokens),
},
body: JSON.stringify({ prompt: "Create an issue" }),
});
```
Checking Authorization [#checking-authorization]
Multiple ways to check if providers are authorized.
```typescript
import { createMCPClient, githubIntegration } from "integrate-sdk";
const client = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
const isAuthorized = await client.isAuthorized("github");
const authorized = await client.authorizedProviders();
console.log(authorized);
const status = await client.getAuthorizationStatus("github");
console.log(status.authorized);
console.log(status.scopes);
console.log(status.expiresAt);
```
Disconnect and Logout [#disconnect-and-logout]
Manage user sessions.
```typescript
import { createMCPClient, githubIntegration } from "integrate-sdk";
const client = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
await client.disconnectProvider("github");
const isAuthorized = await client.isAuthorized("github");
await client.logout();
await client.authorize("github");
await client.authorize("gmail");
```
Complete Example [#complete-example]
Here's a comprehensive example using multiple advanced features:
```typescript
import {
createMCPClient,
githubIntegration,
gmailIntegration,
} from "integrate-sdk";
const client = createMCPClient({
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
gmailIntegration(),
],
connectionMode: "lazy",
singleton: true,
autoCleanup: true,
oauthFlow: {
mode: "popup",
popupOptions: { width: 600, height: 700 },
},
oauthApiBase: "/api/integrate/oauth",
autoHandleOAuthCallback: true,
onReauthRequired: async ({ provider, error }) => {
console.log(`Re-auth needed for ${provider}: ${error.message}`);
await client.authorize(provider);
return true;
},
maxReauthRetries: 2,
timeout: 60000,
headers: {
"X-App-Version": "1.0.0",
},
clientInfo: {
name: "my-awesome-app",
version: "1.0.0",
},
});
client.on("auth:complete", ({ provider }) => {
console.log(`β ${provider} connected`);
});
client.on("auth:error", ({ provider, error }) => {
console.error(`β ${provider} error:`, error);
});
try {
await client.github.createIssue({
owner: "owner",
repo: "repo",
title: "Test issue",
});
} catch (error) {
console.error("Failed to create issue:", error);
}
```
Next Steps [#next-steps]
* Learn about [OAuth Setup in Next.js](/docs/frameworks/frontend/nextjs)
* Integrate with [Vercel AI SDK](/docs/artificial-intelligence/vercel-ai-sdk)
* Check the [API Reference](/docs/reference/options) for complete type definitions
# Basic Usage
**For AI agents:** Start with the Markdown entry point at [`/llms.txt`](/llms.txt). This page is also available at [`/docs/getting-started/basic-usage.mdx`](/docs/getting-started/basic-usage.mdx).
Server Configuration [#server-configuration]
First, create a server configuration file with your OAuth credentials:
```typescript
// lib/integrate.ts
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
clientId: process.env.GITHUB_CLIENT_ID,
clientSecret: process.env.GITHUB_CLIENT_SECRET,
scopes: ["repo", "user"],
}),
],
});
```
You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login).
Client Usage [#client-usage]
The client is automatically configured when making requests to the server.
Here's a complete example that calls a GitHub tool:
```typescript
import { client } from "integrate-sdk";
if (!(await client.isAuthorized("github"))) {
await client.authorize("github");
}
const result = await client.github.createIssue({
owner: "owner",
repo: "repo",
title: "Bug report",
body: "Description of the bug",
});
console.log("Issue created:", result);
```
Client-Side vs Server-Side [#client-side-vs-server-side]
The SDK works in both browser and Node.js environments, but with different capabilities:
Browser Environment β [#browser-environment-]
* Full OAuth authorization UI (popup/redirect)
* Make API calls to integrated services
* Complete session management
Server Environment π₯οΈ [#server-environment-οΈ]
* Make API calls with provider access tokens
* No OAuth UI (throws error if attempted)
* Perfect for backend API routes
```typescript
import { client } from "integrate-sdk";
client.setProviderToken("github", {
accessToken: userAccessToken,
tokenType: "Bearer",
expiresIn: 3600,
});
const repos = await client.github.listRepos({ username: "octocat" });
await client.authorize("github");
```
π‘ **Tip:** Handle OAuth authorization in the browser, then store the access token in your database for backend API calls.
Step-by-Step Breakdown [#step-by-step-breakdown]
1. Import the SDK [#1-import-the-sdk]
```typescript
import { client } from "integrate-sdk";
```
2. Set Up OAuth Credentials [#2-set-up-oauth-credentials]
Before using the SDK, you need to create OAuth apps for the services you want to integrate:
* **GitHub**: Create an OAuth App at [GitHub Developer Settings](https://github.com/settings/developers)
* **Gmail**: Create a project and OAuth 2.0 credentials in [Google Cloud Console](https://console.cloud.google.com)
Store your credentials in environment variables:
```bash
INTEGRATE_API_KEY=your_integrate_api_key
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
GMAIL_CLIENT_ID=your_gmail_client_id
GMAIL_CLIENT_SECRET=your_gmail_client_secret
```
3. Call Tools [#3-call-tools]
```typescript
import { client } from "integrate-sdk";
const result = await client.github.createIssue({
owner: "owner",
repo: "repo",
title: "Bug report",
body: "Description of the bug",
});
```
List Available Tools [#list-available-tools]
To see what tools are available from the server:
```typescript
import { client } from "integrate-sdk";
const tools = await client.getEnabledToolsAsync();
console.log(
"Available tools:",
tools.map((t) => t.name)
);
```
`getEnabledTools()` returns only tools already cached locally. Use `getEnabledToolsAsync()` when you need fresh tool metadata from the server.
Error Handling [#error-handling]
Wrap your code in try-catch blocks to handle errors:
```typescript
import { client } from "integrate-sdk";
try {
const result = await client.github.createIssue({
owner: "owner",
repo: "repo",
title: "Bug report",
});
console.log("Success:", result);
} catch (error) {
console.error("Error:", error.message);
}
```
Next Steps [#next-steps]
* Learn about [OAuth authorization](/docs/getting-started/basic-usage) to handle user authentication
* Explore [Built-in Integrations](/docs/integrations) to see what integrations are available
* Check out [Advanced Usage](/docs/getting-started/advanced-usage) for re-authentication, error handling, and more
* Integrate with [Vercel AI SDK](/docs/artificial-intelligence/vercel-ai-sdk) to give AI models access to your tools
# Database
This page has moved to the [Database](/docs/database) section.
* [Overview](/docs/database)
* [Drizzle adapter](/docs/database/drizzle)
* [Prisma adapter](/docs/database/prisma)
* [MongoDB adapter](/docs/database/mongodb)
* [Schema reference](/docs/database/schema)
* [Triggers](/docs/database/triggers)
* [Hooks](/docs/database/hooks)
* [Examples](https://github.com/integratedotdev/examples/tree/main/database): Drizzle, Prisma, and MongoDB Next.js apps
* [MCP tool scoping](/docs/guides/mcp-tool-scoping): `connectedOnly`, `integrationIds`, Code Mode
* [Performance](/docs/guides/performance): caching, concurrency, cold start
For manual callback configuration (without adapters), see [Schema](/docs/database/schema) and the callback signatures in the [Database overview](/docs/database).
# Installation
import { Tabs, Tab } from "fumadocs-ui/components/tabs";
Install the Integrate SDK using your preferred package manager.
```bash
bun add integrate-sdk
```
```bash
npm install integrate-sdk
```
```bash
pnpm add integrate-sdk
```
```bash
yarn add integrate-sdk
```
TypeScript Support [#typescript-support]
The SDK is built with TypeScript and includes type definitions out of the box. No additional `@types` packages are needed.
Requirements [#requirements]
* Node.js 20.9+ or newer
* TypeScript 5.6+ (for TypeScript projects)
* `integrate-sdk` **0.10.0+** (Google integrations use `google_*` ids; see [migration note](#google-integration-ids-v0100) below)
Google integration ids (v0.10.0+) [#google-integration-ids-v0100]
In **0.10.0**, short Google integration ids were renamed to `google_*` for consistency with blob assets and docs URLs. `gmail` is unchanged.
| Before (β€0.9.x) | Now (0.10.0+) |
| --------------- | ------------------ |
| `gcal` | `google_calendar` |
| `gchat` | `google_chat` |
| `gcontacts` | `google_contacts` |
| `gdocs` | `google_docs` |
| `gdrive` | `google_drive` |
| `gkeep` | `google_keep` |
| `gmeet` | `google_meet` |
| `gsheets` | `google_sheets` |
| `gslides` | `google_slides` |
| `gtasks` | `google_tasks` |
| `ga4` | `google_analytics` |
Update integration factories (`googleCalendarIntegration()`), client namespaces (`client.google_calendar`), env vars (`GOOGLE_CALENDAR_CLIENT_ID`), and tool names (`google_calendar_list_events`) when upgrading.
Examples [#examples]
Browse runnable projects for frameworks, database adapters, and AI SDKs in the [Integrate examples repository](https://github.com/integratedotdev/examples). Frontend and database examples use Next.js by default; backend examples cover Express, Hono, Fastify, and more.
Next Steps [#next-steps]
Now that you have the SDK installed, check out the [Basic Usage](/docs/getting-started/basic-usage) guide to create your first integration.
# Triggers
Triggers allow you to schedule tool executions for a specific time or on a recurring schedule. This enables use cases like sending scheduled emails, daily reports, automated reminders, and AI agents that schedule actions for later.
Triggers are created and managed **in your application** via `createMCPServer` trigger callbacks or the [database adapter](/docs/database/triggers). The Integrate hosted dashboard is for API keys, billing, and usage, not for creating triggers on behalf of your users.
Overview [#overview]
Triggers are stored in your database and executed by the MCP server scheduler. When a trigger fires, the MCP server calls your Next.js API to get the trigger details and OAuth token, executes the tool, and reports the result back.
Architecture [#architecture]
```
Browser β Next.js API β Your Database (trigger storage)
β
MCP Server Scheduler (execution)
```
Setup [#setup]
1. Configure Database Callbacks [#1-configure-database-callbacks]
Add trigger storage callbacks to your server configuration. The SDK pre-processes trigger data before calling your callbacks, so you only need to handle database operations:
```typescript
// lib/integrate-server.ts
import { createMCPServer, githubIntegration, gmailIntegration } from "integrate-sdk/server";
import { db } from "./db"; // Your database client
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
clientId: process.env.GITHUB_CLIENT_ID,
clientSecret: process.env.GITHUB_CLIENT_SECRET,
}),
gmailIntegration({
clientId: process.env.GMAIL_CLIENT_ID,
clientSecret: process.env.GMAIL_CLIENT_SECRET,
}),
],
// Trigger storage callbacks
triggers: {
// SDK pre-processes: generates ID (trig_xxx), extracts provider, sets status='active', timestamps
create: async (trigger, context) => {
// trigger already has: id, provider, status, createdAt, updatedAt
return db.trigger.create({
data: { ...trigger, userId: context?.userId },
});
},
get: async (triggerId, context) => {
return db.trigger.findFirst({
where: { id: triggerId, userId: context?.userId },
});
},
// SDK calculates hasMore from your response
list: async (params, context) => {
const [triggers, total] = await Promise.all([
db.trigger.findMany({
where: {
userId: context?.userId,
status: params.status,
toolName: params.toolName,
},
take: params.limit || 20,
skip: params.offset || 0,
}),
db.trigger.count({
where: {
userId: context?.userId,
status: params.status,
toolName: params.toolName,
},
}),
]);
// Return triggers and total - SDK calculates hasMore automatically
return {
triggers,
total,
};
},
// SDK sets updatedAt automatically on updates
update: async (triggerId, updates, context) => {
return db.trigger.update({
where: { id: triggerId, userId: context?.userId },
data: updates,
});
},
delete: async (triggerId, context) => {
await db.trigger.delete({
where: { id: triggerId, userId: context?.userId },
});
},
},
});
```
SDK Pre-processing [#sdk-pre-processing]
The SDK automatically handles the following before calling your callbacks:
* **ID Generation**: Generates unique IDs in format `trig_{12-character-nanoid}` (e.g., `trig_abc123xyz789`)
* **Provider Extraction**: Extracts provider from tool name (e.g., `gmail_send_email` β `gmail`)
* **Status Defaults**: Sets `status: 'active'` if not provided
* **Timestamps**: Sets `createdAt` and `updatedAt` on create, `updatedAt` on update/pause/resume
* **Status Validation**: Validates pause/resume transitions (only active β paused, paused β active)
* **Pagination**: Calculates `hasMore` flag from your `{triggers, total}` response
Your callbacks are thin database wrappers - just insert/update/query your database.
2. Database Schema [#2-database-schema]
Create a triggers table in your database with the following fields:
```sql
CREATE TABLE triggers (
id VARCHAR(255) PRIMARY KEY,
name VARCHAR(255),
description TEXT,
tool_name VARCHAR(255) NOT NULL,
tool_arguments JSON NOT NULL,
schedule_type VARCHAR(50) NOT NULL,
schedule_value TEXT NOT NULL,
status VARCHAR(50) DEFAULT 'active',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
last_run_at TIMESTAMP,
next_run_at TIMESTAMP,
run_count INT DEFAULT 0,
last_error TEXT,
last_result JSON,
user_id VARCHAR(255),
provider VARCHAR(50)
);
CREATE INDEX idx_triggers_user ON triggers(user_id);
CREATE INDEX idx_triggers_status ON triggers(status);
```
For Prisma:
```prisma
model Trigger {
id String @id
name String?
description String?
toolName String @map("tool_name")
toolArguments Json @map("tool_arguments")
scheduleType String @map("schedule_type")
scheduleValue String @map("schedule_value")
status String @default("active")
createdAt DateTime @default(now()) @map("created_at")
updatedAt DateTime @updatedAt @map("updated_at")
lastRunAt DateTime? @map("last_run_at")
nextRunAt DateTime? @map("next_run_at")
runCount Int @default(0) @map("run_count")
lastError String? @map("last_error")
lastResult Json? @map("last_result")
userId String? @map("user_id")
provider String?
@@index([userId])
@@index([status])
@@map("triggers")
}
```
Usage [#usage]
Creating Triggers [#creating-triggers]
One-Time Trigger [#one-time-trigger]
Schedule a tool execution for a specific date and time:
```typescript
import { client } from "integrate-sdk";
// Send an email at a specific time
const trigger = await client.trigger.create({
name: "Follow-up Email",
toolName: "gmail_send_email",
toolArguments: {
to: "friend@example.com",
subject: "About the dog",
body: "Hey, just wanted to follow up about the dog...",
},
schedule: {
type: "once",
runAt: new Date("2024-12-13T22:00:00Z"),
},
});
console.log("Trigger created:", trigger.id);
```
Recurring Trigger [#recurring-trigger]
Schedule a tool execution on a recurring basis using cron expressions:
```typescript
// Daily standup reminder at 9 AM on weekdays
const standup = await client.trigger.create({
name: "Daily Standup Reminder",
description: "Remind team about daily standup",
toolName: "slack_send_message",
toolArguments: {
channel: "#engineering",
text: "Time for standup! π",
},
schedule: {
type: "cron",
expression: "0 9 * * 1-5", // 9 AM Monday-Friday
},
});
```
Common cron expressions:
* `0 9 * * *` - Every day at 9:00 AM
* `0 9 * * 1-5` - Weekdays at 9:00 AM
* `0 */2 * * *` - Every 2 hours
* `0 0 1 * *` - First day of every month at midnight
* `0 0 * * 0` - Every Sunday at midnight
Listing Triggers [#listing-triggers]
Get all triggers or filter by status. The SDK automatically calculates `hasMore` for pagination:
```typescript
// Get all active triggers
const { triggers, total, hasMore } = await client.trigger.list({
status: "active",
limit: 20,
offset: 0,
});
console.log(`Found ${total} active triggers`);
console.log(`Has more: ${hasMore}`); // SDK calculates this automatically
triggers.forEach((trigger) => {
console.log(`- ${trigger.name}: ${trigger.status}`);
});
// Filter by tool name
const emailTriggers = await client.trigger.list({
toolName: "gmail_send_email",
});
// Pagination example
let offset = 0;
const limit = 20;
let hasMore = true;
while (hasMore) {
const result = await client.trigger.list({ offset, limit });
console.log(`Page ${offset / limit + 1}: ${result.triggers.length} triggers`);
hasMore = result.hasMore;
offset += limit;
}
```
**Note**: Your `list` callback should return `{triggers, total}` - the SDK calculates `hasMore` automatically from the offset, returned count, and total.
Getting a Trigger [#getting-a-trigger]
Retrieve a specific trigger by ID:
```typescript
const trigger = await client.trigger.get("trig_abc123");
console.log("Trigger:", trigger.name);
console.log("Status:", trigger.status);
console.log("Next run:", trigger.nextRunAt);
console.log("Run count:", trigger.runCount);
```
Updating Triggers [#updating-triggers]
Update trigger properties like arguments or schedule:
```typescript
// Update the schedule
await client.trigger.update("trig_abc123", {
schedule: {
type: "cron",
expression: "0 10 * * 1-5", // Changed to 10 AM
},
});
// Update the tool arguments
await client.trigger.update("trig_abc123", {
toolArguments: {
channel: "#general",
text: "Updated message",
},
});
// Update name and description
await client.trigger.update("trig_abc123", {
name: "Updated Name",
description: "New description",
});
```
Pausing and Resuming [#pausing-and-resuming]
Temporarily stop a trigger without deleting it. The SDK validates status transitions automatically:
```typescript
// Pause a trigger (stops future executions)
// Only works if trigger status is 'active'
await client.trigger.pause("trig_abc123");
// Resume a paused trigger
// Only works if trigger status is 'paused'
await client.trigger.resume("trig_abc123");
// Invalid transitions return an error:
// - Cannot pause a trigger that's already paused, completed, or failed
// - Cannot resume a trigger that's not paused
```
The SDK automatically:
* Validates the current status before allowing pause/resume
* Sets `updatedAt` timestamp on status changes
* Returns descriptive error messages for invalid transitions
Manual Execution [#manual-execution]
Execute a trigger immediately, bypassing the schedule:
```typescript
const result = await client.trigger.run("trig_abc123");
if (result.success) {
console.log("Execution successful:", result.result);
} else {
console.error("Execution failed:", result.error);
}
console.log("Duration:", result.duration, "ms");
```
Deleting Triggers [#deleting-triggers]
Permanently delete a trigger:
```typescript
await client.trigger.delete("trig_abc123");
```
AI Agent Integration [#ai-agent-integration]
Triggers are perfect for AI agents that need to schedule actions based on natural language requests:
```typescript
async function handleAIRequest(userMessage: string) {
// AI processes: "Send an email about the dog on December 13 at 10 PM"
const parsed = await ai.parse(userMessage);
if (parsed.intent === "schedule_email") {
const trigger = await client.trigger.create({
toolName: "gmail_send_email",
toolArguments: {
to: parsed.recipient,
subject: parsed.subject,
body: parsed.body,
},
schedule: {
type: "once",
runAt: parsed.scheduledTime, // "2024-12-13T22:00:00Z"
},
});
return `I've scheduled the email to be sent on ${parsed.scheduledTime}`;
}
}
```
Advanced Usage [#advanced-usage]
Multi-Tenant Support [#multi-tenant-support]
Use the context parameter to isolate triggers by user:
```typescript
// Server configuration with user context
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [...],
// Extract user ID from session
getSessionContext: async (request) => {
const session = await getSession(request);
return { userId: session.userId };
},
triggers: {
create: async (trigger, context) => {
// context.userId is automatically provided
return db.trigger.create({
data: { ...trigger, userId: context?.userId },
});
},
// ... other callbacks
},
});
```
Error Handling [#error-handling]
Handle trigger execution errors:
```typescript
const { triggers } = await client.trigger.list({ status: "failed" });
for (const trigger of triggers) {
console.log(`Trigger ${trigger.name} failed:`);
console.log(`Error: ${trigger.lastError}`);
console.log(`Last attempt: ${trigger.lastRunAt}`);
// Optionally retry
try {
await client.trigger.run(trigger.id);
} catch (error) {
console.error("Retry failed:", error);
}
}
```
Monitoring [#monitoring]
Track trigger execution history:
```typescript
const trigger = await client.trigger.get("trig_abc123");
console.log("Execution stats:");
console.log(`- Total runs: ${trigger.runCount}`);
console.log(`- Last run: ${trigger.lastRunAt}`);
console.log(`- Next run: ${trigger.nextRunAt}`);
console.log(`- Status: ${trigger.status}`);
if (trigger.lastResult) {
console.log("Last result:", trigger.lastResult);
}
if (trigger.lastError) {
console.error("Last error:", trigger.lastError);
}
```
Type Definitions [#type-definitions]
Trigger [#trigger]
```typescript
interface Trigger {
id: string;
name?: string;
description?: string;
toolName: string;
toolArguments: Record;
schedule: TriggerSchedule;
status: "active" | "paused" | "completed" | "failed";
createdAt: string;
updatedAt: string;
lastRunAt?: string;
nextRunAt?: string;
runCount?: number;
lastError?: string;
lastResult?: Record;
userId?: string;
provider?: string;
}
```
TriggerSchedule [#triggerschedule]
```typescript
type TriggerSchedule =
| { type: "once"; runAt: string | Date }
| { type: "cron"; expression: string };
```
CreateTriggerInput [#createtriggerinput]
```typescript
interface CreateTriggerInput {
name?: string;
description?: string;
toolName: string;
toolArguments: Record;
schedule: TriggerSchedule;
status?: "active" | "paused" | "completed" | "failed"; // Optional, defaults to 'active'
}
```
**Note**: The SDK pre-processes this input before calling your `create` callback. Your callback receives a fully processed `Trigger` object with:
* Generated `id` (format: `trig_{nanoid}`)
* Extracted `provider` from `toolName`
* Default `status: 'active'` if not provided
* `createdAt` and `updatedAt` timestamps
TriggerExecutionResult [#triggerexecutionresult]
```typescript
interface TriggerExecutionResult {
success: boolean;
result?: Record;
error?: string;
executedAt: string;
duration?: number;
}
```
SDK Pre-processing Details [#sdk-pre-processing-details]
The SDK handles all trigger data pre-processing, making your callbacks simple database operations:
What the SDK Pre-processes [#what-the-sdk-pre-processes]
**On Create:**
* Generates unique ID: `trig_{12-character-nanoid}` (e.g., `trig_abc123xyz789`)
* Extracts provider from tool name: `gmail_send_email` β `gmail`
* Sets default status: `'active'` if not provided
* Sets timestamps: `createdAt` and `updatedAt` to current time
**On Update:**
* Automatically sets `updatedAt` timestamp
**On Pause/Resume:**
* Validates status transitions:
* Pause: Only allows `active` β `paused`
* Resume: Only allows `paused` β `active`
* Sets `updatedAt` timestamp
* Returns descriptive errors for invalid transitions
**On List:**
* Calculates `hasMore` flag: `(offset + triggers.length) < total`
* Your callback only needs to return `{triggers, total}`
Benefits [#benefits]
* **Consistent IDs**: All triggers use the same nanoid-based format
* **Less Code**: No need to generate IDs or extract providers in your callbacks
* **Type Safety**: Fully typed trigger objects throughout
* **Validation**: Status transitions validated before database calls
* **Simpler Callbacks**: Focus on database operations only
Best Practices [#best-practices]
Use Descriptive Names [#use-descriptive-names]
Give your triggers meaningful names for easier management:
```typescript
await client.trigger.create({
name: "Weekly Sales Report - Mondays 9 AM",
description: "Send sales report to team@company.com",
// ...
});
```
Handle Timezone Differences [#handle-timezone-differences]
When creating one-time triggers, ensure you're using the correct timezone:
```typescript
// Use UTC timestamps
const utcTime = new Date("2024-12-13T22:00:00Z");
// Or convert from local time
const localTime = new Date("2024-12-13T14:00:00"); // 2 PM local
const utcTime = new Date(localTime.toISOString());
await client.trigger.create({
schedule: { type: "once", runAt: utcTime },
// ...
});
```
Clean Up Completed Triggers [#clean-up-completed-triggers]
Remove one-time triggers after they complete:
```typescript
const { triggers } = await client.trigger.list({ status: "completed" });
for (const trigger of triggers) {
// Keep for audit or delete immediately
await client.trigger.delete(trigger.id);
}
```
Test Before Scheduling [#test-before-scheduling]
Use manual execution to test triggers before scheduling:
```typescript
// Create trigger with paused status (SDK accepts custom status)
const trigger = await client.trigger.create({
name: "Test Email",
toolName: "gmail_send_email",
toolArguments: { /* ... */ },
schedule: { type: "cron", expression: "0 9 * * *" },
status: "paused", // Create as paused to prevent automatic execution
});
// Test execution
const result = await client.trigger.run(trigger.id);
if (result.success) {
// Resume if test passed (SDK validates status transition)
await client.trigger.resume(trigger.id);
} else {
console.error("Test failed:", result.error);
// Keep paused or delete
}
```
**Note**: The SDK validates that you can only resume triggers with status `'paused'`. If you create a trigger with a different status, you'll need to handle transitions appropriately.
Troubleshooting [#troubleshooting]
Trigger Not Executing [#trigger-not-executing]
1. **Check trigger status**: Ensure it's `active`, not `paused`
2. **Verify schedule**: Check `nextRunAt` to see when it will execute
3. **Check OAuth token**: Ensure the provider is authorized
4. **Review errors**: Check `lastError` for execution failures
```typescript
const trigger = await client.trigger.get("trig_abc123");
if (trigger.status === "paused") {
// SDK validates status - only resumes if status is 'paused'
await client.trigger.resume(trigger.id);
} else if (trigger.status === "failed") {
// Failed triggers cannot be resumed directly
// You may need to update status or create a new trigger
console.error("Trigger failed:", trigger.lastError);
}
if (trigger.lastError) {
console.error("Last error:", trigger.lastError);
}
```
Status Transition Errors [#status-transition-errors]
If you get errors when pausing or resuming, check the trigger's current status:
```typescript
try {
await client.trigger.pause("trig_abc123");
} catch (error) {
// Error message will indicate why pause failed:
// - "Cannot pause trigger with status 'paused'"
// - "Cannot pause trigger with status 'completed'"
// - etc.
console.error("Pause failed:", error.message);
const trigger = await client.trigger.get("trig_abc123");
console.log("Current status:", trigger.status);
}
```
OAuth Token Expired [#oauth-token-expired]
If a trigger fails due to expired tokens, the user needs to re-authorize:
```typescript
const trigger = await client.trigger.get("trig_abc123");
if (trigger.provider) {
const isAuthorized = await client.isAuthorized(trigger.provider);
if (!isAuthorized) {
console.log("Re-authorization required for", trigger.provider);
await client.authorize(trigger.provider);
}
}
```
Invalid Cron Expression [#invalid-cron-expression]
Validate cron expressions before creating triggers:
```typescript
function isValidCron(expression: string): boolean {
// Basic validation - 5 parts (minute, hour, day, month, weekday)
const parts = expression.split(" ");
return parts.length === 5;
}
const cronExpression = "0 9 * * 1-5";
if (!isValidCron(cronExpression)) {
throw new Error("Invalid cron expression");
}
await client.trigger.create({
schedule: { type: "cron", expression: cronExpression },
// ...
});
```
Examples [#examples]
Daily Summary Email [#daily-summary-email]
```typescript
await client.trigger.create({
name: "Daily Summary Email",
description: "Send daily summary at 6 PM",
toolName: "gmail_send_email",
toolArguments: {
to: "team@company.com",
subject: "Daily Summary - {{date}}",
body: "Today's summary...",
},
schedule: {
type: "cron",
expression: "0 18 * * *", // 6 PM daily
},
});
```
Weekly GitHub Issue Reminder [#weekly-github-issue-reminder]
```typescript
await client.trigger.create({
name: "Weekly Issue Review",
description: "Remind team to review open issues",
toolName: "slack_send_message",
toolArguments: {
channel: "#engineering",
text: "π Time to review open GitHub issues!",
},
schedule: {
type: "cron",
expression: "0 10 * * 1", // Mondays at 10 AM
},
});
```
Birthday Email [#birthday-email]
```typescript
await client.trigger.create({
name: "Birthday Email for John",
toolName: "gmail_send_email",
toolArguments: {
to: "john@company.com",
subject: "Happy Birthday! π",
body: "Wishing you a wonderful birthday!",
},
schedule: {
type: "once",
runAt: new Date("2024-06-15T09:00:00Z"),
},
});
```
# MCP Tool Scoping
Integrate uses three independent layers to scope MCP tools. Understanding them prevents slow tool discovery and models seeing tools the user cannot use.
The three layers [#the-three-layers]
| Layer | Mechanism | Controls |
| ---------------------- | ------------------------------------------------------------------ | ------------------------------------------ |
| **Integration config** | Integrations passed to `createMCPServer` + `X-Integrations` header | Which tool *definitions* exist in your app |
| **OAuth tokens** | `getProviderToken(provider, email, context)` on each `tools/call` | Whether a tool *executes* for a user |
| **API key** | `apiKey` on server config β `X-API-Key` on MCP requests | Billing, rate limits, usage `userId` |
Listing is **config-based** by default: if Gmail is in your server config, Gmail tools appear even when the user has not connected Gmail. Execution fails without a token.
Connected-only tool loading [#connected-only-tool-loading]
Use `connectedOnly` when building AI tools for a signed-in user so you only fetch schemas for integrations they have OAuth tokens for:
```typescript
import { getVercelAITools } from "integrate-sdk/server";
import { serverClient } from "@/lib/integrate";
const tools = await getVercelAITools(serverClient, {
context: { userId: session.user.id },
connectedOnly: true,
mode: "code",
});
```
This calls `getProviderToken` per configured integration (via your database adapter or callbacks) and only runs `list_tools_by_integration` for providers with usable tokens.
Manual integration filter [#manual-integration-filter]
Pass an explicit allowlist when you already know which providers to expose:
```typescript
const tools = await getVercelAITools(serverClient, {
integrationIds: ["github", "gmail", "slack"],
context: { userId },
});
```
Or on the client directly:
```typescript
const mcpTools = await serverClient.getEnabledToolsAsync({
integrationIds: ["github"],
context: { userId },
});
```
listConnectedProviders helper [#listconnectedproviders-helper]
For custom logic (routing, UI badges, background jobs), use the exported helper:
```typescript
import { listConnectedProviders } from "integrate-sdk/server";
const connected = await listConnectedProviders(
["github", "gmail", "slack"],
(provider, email, context) =>
serverClient.getProviderToken(provider, email, context),
{ userId: session.user.id }
);
```
With a database adapter, `getProviderToken` is already wired. You can also derive connected providers from token rows using `listConnectedProvidersFromRows`.
Code Mode + scoping [#code-mode--scoping]
[Code Mode](/docs/artificial-intelligence/code-mode) collapses hundreds of MCP tools into `execute_code` + `get_types`, which dramatically reduces context size. Pair it with `connectedOnly` so cold-start discovery only hits integrations the user has connected:
```typescript
const tools = await getVercelAITools(serverClient, {
context: { userId },
connectedOnly: true,
mode: "code",
});
```
Set `codeMode.publicUrl` or `INTEGRATE_URL` so Code Mode can call back into `/api/integrate/mcp`.
Triggers and automations [#triggers-and-automations]
Scheduled work belongs in **your application database**, not the Integrate platform dashboard. Configure `triggers` callbacks or the [database adapter](/docs/database) in your app; the MCP scheduler calls your `/api/integrate/triggers/notify` route.
The hosted dashboard at integrate.dev is for API keys, billing, and usage, not for creating triggers on behalf of your users.
Related [#related]
* [Performance](/docs/guides/performance): caching and concurrency
* [Database adapters](/docs/database): token storage and `connectedOnly`
* [Triggers](/docs/getting-started/triggers): SDK trigger callbacks
# Native Automations with SDK Primitives
Production apps like [Individu](https://github.com/integratedotdev/individu) often outgrow SDK-managed trigger CRUD but still rely on integrate-sdk for the hard parts: OAuth tokens, MCP tool execution, and multi-step callbacks.
When to use what [#when-to-use-what]
| Pattern | Use when |
| ------------------------------------------------------------------ | ------------------------------------------------------------------------------------- |
| **SDK triggers** (`triggers.onComplete`, `serverClient.trigger.*`) | You want scheduler registration + CRUD handled by the SDK |
| **Native orchestration** | You own scheduling (cron, queues, Vercel cron) but call MCP tools server-side |
| **Hybrid** | Legacy SDK triggers + new native automations; share `onComplete` for multi-step flows |
Server-side tool execution [#server-side-tool-execution]
Use the public `callTool` API (not `_callToolByName`):
```typescript
import { serverClient } from "@/lib/integrate";
import { parseMCPToolResult } from "integrate-sdk/server";
const raw = await serverClient.callTool("github_list_repos", { per_page: 10 }, {
context: { userId },
});
const result = parseMCPToolResult(raw);
if (!result.ok) {
throw new Error(result.error);
}
```
`parseMCPToolResult` normalizes MCP `isError`, `success: false`, `structuredContent`, and text `content` blocks.
Multi-step orchestration (onComplete) [#multi-step-orchestration-oncomplete]
Wire SDK trigger callbacks when steps should chain:
```typescript
createMCPServer({
// ...
triggers: {
onComplete: async (ctx) => {
// ctx.request.steps: normalize with parseMCPToolResult per step
// return { hasMore, nextStep } for chained execution
return { hasMore: false };
},
getCallbackUrl: () => process.env.APP_URL!,
},
});
```
Types: `StepResult`, `CompleteCallbackContext`, `CompleteResponse` from `integrate-sdk`.
Template variables between steps [#template-variables-between-steps]
Resolve outputs from prior steps in your orchestrator (see Individu's `lib/automations/template.ts` pattern). Keep templates in your app; the SDK provides execution + result parsing only.
Performance for automation agents [#performance-for-automation-agents]
Reuse cached AI tools across chat and automation paths:
```typescript
import { getVercelAITools } from "integrate-sdk/server";
import { createMemoryToolDiscoveryCache } from "integrate-sdk/server";
const cache = createMemoryToolDiscoveryCache();
const tools = await getVercelAITools(serverClient, {
context: { userId },
connectedOnly: true,
mode: "code",
cache: { cache, ttlMs: 5 * 60 * 1000 },
});
```
Invalidate on OAuth connect/disconnect via `createToolDiscoveryCacheInvalidator(cache)` in your database adapter `onTokenChange` hook.
# Performance
Cold-start tool discovery is the most common performance issue in production apps with many integrations. This guide covers patterns that keep chat and automation startup fast.
Problem: N integrations Γ network round-trips [#problem-n-integrations--network-round-trips]
`getEnabledToolsAsync()` fetches tool schemas via `list_tools_by_integration` once per configured integration. With 100+ integrations and concurrency 8, a cold serverless instance can still take several seconds before the first chat turn.
Mitigations (use together):
1. **`connectedOnly: true`**: only fetch integrations the user has OAuth tokens for
2. **`mode: 'code'`**: expose 2 AI tools instead of hundreds ([Code Mode](/docs/artificial-intelligence/code-mode))
3. **`hydrateToolCache`**: skip network discovery when metadata is already known
4. **Raise `fetchConcurrency`** when you must fetch many integrations at once
Connected-only discovery [#connected-only-discovery]
```typescript
await serverClient.getEnabledToolsAsync({
connectedOnly: true,
context: { userId },
fetchConcurrency: 8, // default in v0.10.0+
});
```
For AI helpers:
```typescript
await getVercelAITools(serverClient, {
context: { userId },
connectedOnly: true,
mode: "code",
});
```
Invalidate your app-level cache when tokens change (OAuth connect/disconnect).
Built-in tool discovery cache (v0.10.0+) [#built-in-tool-discovery-cache-v0100]
Pass a `cache` adapter to `getVercelAITools` instead of hand-rolling Redis + `hydrateToolCache`:
```typescript
import {
getVercelAITools,
createMemoryToolDiscoveryCache,
createToolDiscoveryCacheInvalidator,
} from "integrate-sdk/server";
const cache = createMemoryToolDiscoveryCache();
const tools = await getVercelAITools(serverClient, {
context: { userId },
connectedOnly: true,
mode: "code",
cache: { cache, ttlMs: 5 * 60 * 1000 },
});
// In drizzleAdapter onTokenChange:
createToolDiscoveryCacheInvalidator(cache)({ userId });
```
Implement `ToolDiscoveryCacheAdapter` for Redis (see production Next.js guide). Keys default to `userId:provider1,provider2`.
hydrateToolCache for serverless [#hydratetoolcache-for-serverless]
The SDK exposes `hydrateToolCache` on the server client so you can restore tool metadata without per-integration fetches:
```typescript
// After a previous discovery pass, persist stubs (name, description, inputSchema)
serverClient.hydrateToolCache(cachedStubs);
// Subsequent getEnabledToolsAsync / getVercelAITools calls use the cache
const tools = await getVercelAITools(serverClient, {
context: { userId },
connectedOnly: true,
});
```
**Production pattern:** persist stubs in Redis keyed by `userId` (and connected-provider set). On cold start, hydrate before calling `getVercelAITools`. Clear the cache when `onTokenChange` fires from your database adapter.
Include connected providers in your cache key so reconnecting OAuth invalidates stale tool lists:
```typescript
const cacheKey = `${userId}:${connectedProviders.sort().join(",")}`;
```
Code Mode default [#code-mode-default]
Code Mode still runs discovery internally, but the model only receives `execute_code` and `get_types`. Always set `codeMode.publicUrl` or `INTEGRATE_URL` on the server:
```typescript
createMCPServer({
codeMode: { publicUrl: process.env.INTEGRATE_URL },
// ...
});
```
Usage tracking [#usage-tracking]
Tool calls must include your server `apiKey` so the MCP server can attribute usage to the correct customer. Ensure:
* `INTEGRATE_API_KEY` is set in your app (server-only)
* Your dashboard `/api/usage` route is reachable from the MCP server (no auth session redirect)
* `MCP_SERVER_SECRET` matches between MCP server and dashboard
* `APP_BASE_URL` on the MCP server points at your dashboard origin
See your dashboard `ENV_SETUP.md` for the full usage pipeline.
Related [#related]
* [MCP Tool Scoping](/docs/guides/mcp-tool-scoping)
* [Code Mode](/docs/artificial-intelligence/code-mode)
* [Database hooks](/docs/database/hooks): `onTokenChange` for cache invalidation
# Production Next.js App
This guide summarizes patterns proven in production apps using integrate-sdk with Next.js App Router, session-based auth, and Vercel AI SDK.
Server setup [#server-setup]
```typescript
// lib/integrate.ts
import {
createMCPServer,
createIntegrationBundle,
createMemoryToolDiscoveryCache,
createToolDiscoveryCacheInvalidator,
} from "integrate-sdk/server";
import { drizzleAdapter } from "integrate-sdk/adapters/drizzle";
import { db } from "@/database";
import { providerToken, trigger } from "@/database/schema";
const toolDiscoveryCache = createMemoryToolDiscoveryCache();
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY!,
apiBaseUrl: process.env.APP_URL,
codeMode: { publicUrl: process.env.INTEGRATE_URL ?? process.env.APP_URL },
integrations: createIntegrationBundle({ include: ["github", "gmail", "slack"] }),
enabledProviders: ["github", "gmail", "slack"],
database: drizzleAdapter(db, {
provider: "pg",
schema: { providerToken, trigger },
hooks: {
onTokenChange: ({ userId }) => {
void toolDiscoveryCache.invalidate(userId);
},
},
}),
getSessionContext: async (req) => {
const session = await auth.api.getSession({ headers: req.headers });
return session?.user?.id ? { userId: session.user.id } : undefined;
},
triggers: {
onComplete: handleTriggerCompletion,
getCallbackUrl: () => process.env.APP_URL!,
},
});
```
Route handler [#route-handler]
```typescript
// app/api/integrate/[...all]/route.ts
import { serverClient } from "@/lib/integrate";
import { toNextJsHandler } from "integrate-sdk/server";
export const maxDuration = 300;
export const { POST, GET } = toNextJsHandler(serverClient);
```
Tool name normalization runs inside the SDK handler. No app-level POST wrapper is required.
AI chat tools [#ai-chat-tools]
```typescript
import { getVercelAITools } from "integrate-sdk/server";
import { serverClient } from "@/lib/integrate";
const tools = await getVercelAITools(serverClient, {
context: { userId: session.user.id },
connectedOnly: true,
mode: "code",
cache: { cache: toolDiscoveryCache, ttlMs: 300_000 },
});
```
See [Performance](/docs/guides/performance) and [MCP Tool Scoping](/docs/guides/mcp-tool-scoping).
Browser OAuth UI [#browser-oauth-ui]
```tsx
"use client";
import { client } from "integrate-sdk";
import { useIntegrateAuth } from "integrate-sdk/react";
function ConnectGitHub() {
const { isAuthorized, authorize, isLoading } = useIntegrateAuth(client, "github");
return (
);
}
```
Disconnect multi-account tokens with `disconnectAccount(provider, email, { userId })` on the server.
Internal service auth [#internal-service-auth]
Background jobs that call MCP tools without a user session should pass explicit context:
```typescript
await serverClient.callTool("gmail_list_messages", { maxResults: 5 }, {
context: { userId: actorUserId },
});
```
Protect internal routes with shared secrets validated in `getSessionContext`.
Related guides [#related-guides]
* [Native Automations](/docs/guides/native-automations): hybrid scheduling
* [Code Mode](/docs/artificial-intelligence/code-mode)
* [Triggers](/docs/getting-started/triggers)
# Options
createMCPClient [#createmcpclient]
Creates a new MCP client instance.
```typescript
function createMCPClient(config: MCPClientConfig): MCPClient;
```
Parameters [#parameters]
Returns [#returns]
An `MCPClient` instance.
Example [#example]
```typescript
const client = createMCPClient({
integrations: [
githubIntegration({
clientId: process.env.GITHUB_CLIENT_ID!,
clientSecret: process.env.GITHUB_CLIENT_SECRET!,
}),
],
timeout: 60000,
headers: {
"User-Agent": "my-app/1.0.0",
},
clientInfo: {
name: "my-app",
version: "1.0.0",
},
});
```
MCPClient [#mcpclient]
The main client class for interacting with the MCP server.
connect() [#connect]
Establishes connection to the MCP server.
```typescript
async connect(): Promise
```
**Example:**
```typescript
await client.connect();
```
disconnect() [#disconnect]
Closes the connection to the MCP server.
```typescript
async disconnect(): Promise
```
**Example:**
```typescript
await client.disconnect();
```
Typed Integration Methods [#typed-integration-methods]
Built-in integrations (GitHub, Gmail) provide fully typed methods for calling tools.
**GitHub Integration Methods:**
```typescript
client.github.createIssue(params);
client.github.listIssues(params);
client.github.getRepo(params);
client.github.createPullRequest(params);
// ... and more
```
**Gmail Integration Methods:**
```typescript
client.gmail.sendEmail(params);
client.gmail.listEmails(params);
client.gmail.searchEmails(params);
client.gmail.createLabel(params);
// ... and more
```
**Server Methods:**
```typescript
client.server.listToolsByIntegration(params);
client.server.listAllProviders();
client.server.listConfiguredIntegrations();
// ... other server-level tools
```
**Example:**
```typescript
// Fully typed with IntelliSense support
const result = await client.github.createIssue({
owner: "owner",
repo: "repo",
title: "Bug report",
body: "Description",
});
```
_callToolByName() [#_calltoolbyname]
For integrations configured with `genericOAuthIntegration` or `createSimpleIntegration`, use this internal method to call tools directly.
```typescript
async _callToolByName(name: string, args?: Record): Promise
```
**Parameters:**
* `name` - Full tool name (e.g., 'slack\_send\_message')
* `args` - Tool arguments as key-value pairs (optional)
**Returns:**
* `MCPToolCallResponse` - Tool execution result
**Example:**
```typescript
const result = await client._callToolByName("slack_send_message", {
channel: "#general",
text: "Hello!",
});
```
getTool() [#gettool]
Gets a specific tool definition.
```typescript
getTool(name: string): MCPTool | undefined
```
**Parameters:**
* `name` - Tool name
**Returns:**
* `MCPTool` or `undefined` if not found
**Example:**
```typescript
const tool = client.getTool("github_create_issue");
console.log(tool?.inputSchema);
```
getEnabledTools() [#getenabledtools]
Gets all enabled tools (filtered by integrations).
```typescript
getEnabledTools(): MCPTool[]
```
**Returns:**
* Array of `MCPTool` objects
**Example:**
```typescript
const tools = client.getEnabledTools();
console.log(
"Enabled tools:",
tools.map((t) => t.name)
);
```
getAvailableTools() [#getavailabletools]
Gets all available tools from the server (unfiltered).
```typescript
getAvailableTools(): MCPTool[]
```
**Returns:**
* Array of `MCPTool` objects
**Example:**
```typescript
const tools = client.getAvailableTools();
console.log(
"All tools:",
tools.map((t) => t.name)
);
```
getOAuthConfig() [#getoauthconfig]
Gets OAuth configuration for a specific integration.
```typescript
getOAuthConfig(integrationId: string): OAuthConfig | undefined
```
**Parameters:**
* `integrationId` - Integration identifier
**Returns:**
* `OAuthConfig` or `undefined` if not found
**Example:**
```typescript
const config = client.getOAuthConfig("github");
console.log("Scopes:", config?.scopes);
```
getAllOAuthConfigs() [#getalloauthconfigs]
Gets all OAuth configurations.
```typescript
getAllOAuthConfigs(): Map
```
**Returns:**
* Map of integration IDs to OAuth configurations
**Example:**
```typescript
const configs = client.getAllOAuthConfigs();
for (const [integrationId, config] of configs) {
console.log(`${integrationId}: ${config.provider}`);
}
```
onMessage() [#onmessage]
Registers a message handler.
```typescript
onMessage(handler: (message: any) => void): () => void
```
**Parameters:**
* `handler` - Function to handle messages
**Returns:**
* Unsubscribe function
**Example:**
```typescript
const unsubscribe = client.onMessage((message) => {
console.log("Message:", message);
});
// Later...
unsubscribe();
```
isConnected() [#isconnected]
Checks if the client is connected.
```typescript
isConnected(): boolean
```
**Returns:**
* `true` if connected, `false` otherwise
**Example:**
```typescript
if (client.isConnected()) {
console.log("Client is connected");
}
```
isInitialized() [#isinitialized]
Checks if the client is initialized.
```typescript
isInitialized(): boolean
```
**Returns:**
* `true` if initialized, `false` otherwise
**Example:**
```typescript
if (client.isInitialized()) {
console.log("Client is initialized");
}
```
getAuthState() [#getauthstate]
Gets authentication state for a specific provider.
```typescript
getAuthState(provider: string): { authenticated: boolean; lastError?: AuthenticationError } | undefined
```
**Parameters:**
* `provider` - Provider identifier (e.g., 'github', 'gmail')
**Returns:**
* Authentication state object or `undefined` if provider not found
**Example:**
```typescript
const authState = client.getAuthState("github");
if (authState) {
console.log("Authenticated:", authState.authenticated);
if (authState.lastError) {
console.log("Last error:", authState.lastError.message);
}
}
```
isProviderAuthenticated() [#isproviderauthenticated]
Checks if a specific provider is authenticated.
```typescript
isProviderAuthenticated(provider: string): boolean
```
**Parameters:**
* `provider` - Provider identifier
**Returns:**
* `true` if authenticated, `false` otherwise
**Example:**
```typescript
if (client.isProviderAuthenticated("github")) {
console.log("GitHub is authenticated");
}
```
reauthenticate() [#reauthenticate]
Manually triggers re-authentication for a provider.
```typescript
async reauthenticate(provider: string): Promise
```
**Parameters:**
* `provider` - Provider identifier
**Returns:**
* `true` if re-authentication succeeded, `false` otherwise
**Throws:**
* Error if provider not found or no re-auth handler configured
**Example:**
```typescript
try {
const success = await client.reauthenticate("github");
if (success) {
console.log("Re-authentication successful");
}
} catch (error) {
console.error("Re-authentication failed:", error);
}
```
Server Namespace Methods [#server-namespace-methods]
The `server` namespace provides access to server-level tools and utilities that don't belong to a specific integration.
client.server.listAllProviders() [#clientserverlistallproviders]
List all providers available on the MCP server.
```typescript
async listAllProviders(): Promise
```
**Returns:**
* `MCPToolCallResponse` - Response containing all available providers
**Example:**
```typescript
const result = await client.server.listAllProviders();
console.log("All providers:", result);
```
client.server.listToolsByIntegration() [#clientserverlisttoolsbyintegration]
List all tools available for a specific integration.
```typescript
async listToolsByIntegration(params: {
integration: string;
}): Promise
```
**Parameters:**
* `params.integration` (string) - The integration identifier (e.g., "github", "gmail")
**Returns:**
* `MCPToolCallResponse` - Response containing tools for the specified integration
**Example:**
```typescript
// List all GitHub tools
const result = await client.server.listToolsByIntegration({
integration: "github",
});
console.log("GitHub tools:", result);
```
client.server.listConfiguredIntegrations() [#clientserverlistconfiguredintegrations]
List integrations configured for your application. The behavior depends on how you created your client:
* **Default client** (`import { client } from 'integrate-sdk'`): Fetches from server to get integrations configured via `createMCPServer()`
* **Custom client** (`createMCPClient({ integrations: [...] })`): Returns local config (no server call)
* **Server client** (`createMCPServer`): Returns local config (they ARE the server)
```typescript
async listConfiguredIntegrations(options?: {
includeToolMetadata?: boolean;
}): Promise<{
integrations: ConfiguredIntegration[];
}>
```
**Parameters:**
* `options` (optional) - Configuration options
* `includeToolMetadata` (boolean, default: false) - If true, fetches full tool metadata from the server for all configured integrations. Uses batched requests with concurrency control to avoid rate limiting.
**Returns:**
* Object with `integrations` array containing:
* `id` (string) - Integration identifier
* `name` (string) - Integration display name
* `logoUrl` (string | undefined) - URL to the integration's logo image
* `tools` (readonly string\[]) - Array of tool names available for this integration
* `hasOAuth` (boolean) - Whether the integration requires OAuth
* `scopes` (readonly string\[] | undefined) - OAuth scopes if applicable
* `provider` (string | undefined) - OAuth provider name if applicable
* `description` (string | undefined) - Short library blurb from the integration or the SDK catalog
* `category` (string | undefined) - Library grouping label (e.g. Productivity, Business) from the integration or the SDK catalog
* `toolMetadata` (ToolMetadata\[] | undefined) - Full tool metadata when `includeToolMetadata: true` is passed
**Example (default client - fetches from server):**
```typescript
import { client } from "integrate-sdk";
// Fetches from server to get what's actually configured
const { integrations } = await client.server.listConfiguredIntegrations();
console.log(`Server has ${integrations.length} integrations:`);
integrations.forEach((integration) => {
console.log(`- ${integration.name} (${integration.id})`);
});
```
**Example (custom client - local config):**
```typescript
import { createMCPClient, githubIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [githubIntegration()],
});
// Returns local config - no server call
const { integrations } = await customClient.server.listConfiguredIntegrations();
// Returns [{ id: 'github', ... }]
```
**Example (with metadata - includes server calls):**
```typescript
// Get configured integrations with full tool metadata
const { integrations } = await client.server.listConfiguredIntegrations({
includeToolMetadata: true,
});
integrations.forEach((integration) => {
console.log(`${integration.name}:`);
integration.toolMetadata?.forEach((tool) => {
console.log(` - ${tool.name}`);
console.log(` ${tool.description}`);
if (tool.inputSchema) {
console.log(` Required: ${tool.inputSchema.required?.join(', ') || 'none'}`);
}
});
});
```
**Note:**
* The default client fetches from the server because it has all integrations pre-configured but only some may be configured on the server with OAuth credentials.
* Custom clients return local config because the developer explicitly chose which integrations to use.
* With `includeToolMetadata: true`, it fetches tool metadata for all integrations using batched requests with concurrency control (3 parallel requests at a time) to avoid rate limiting.
* If metadata fetching fails for an integration, it returns an empty array for that integration's `toolMetadata` rather than failing the entire operation.
Type Definitions [#type-definitions]
MCPTool [#mcptool]
MCPToolCallResponse [#mcptoolcallresponse]
MCPToolCallParams [#mcptoolcallparams]
OAuthConfig [#oauthconfig]
MCPIntegration [#mcpintegration]
ConfiguredIntegration [#configuredintegration]
ReauthContext [#reauthcontext]
OAuth Types [#oauth-types]
PopupOptions [#popupoptions]
OAuthFlowConfig [#oauthflowconfig]
AuthStatus [#authstatus]
ProviderTokenData [#providertokendata]
OAuthCallbackParams [#oauthcallbackparams]
OAuth Event Types [#oauth-event-types]
AuthStartedEvent [#authstartedevent]
AuthCompleteEvent [#authcompleteevent]
AuthErrorEvent [#autherrorevent]
AuthLogoutEvent [#authlogoutevent]
AuthDisconnectEvent [#authdisconnectevent]
Built-in Integrations [#built-in-integrations]
githubIntegration() [#githubintegration]
Creates a GitHub integration.
```typescript
function githubIntegration(config: GitHubIntegrationConfig): MCPIntegration;
```
gmailIntegration() [#gmailintegration]
Creates a Gmail integration.
```typescript
function gmailIntegration(config: GmailIntegrationConfig): MCPIntegration;
```
genericOAuthIntegration() [#genericoauthintegration]
Creates a generic OAuth integration.
```typescript
function genericOAuthIntegration(
config: GenericOAuthIntegrationConfig
): MCPIntegration;
```
createSimpleIntegration() [#createsimpleintegration]
Creates a simple integration without OAuth.
```typescript
function createSimpleIntegration(config: {
id: string;
tools: string[];
onInit?: (client: any) => Promise | void;
onAfterConnect?: (client: any) => Promise | void;
onDisconnect?: (client: any) => Promise | void;
}): MCPIntegration;
```
**Parameters:**
* `id` - Integration identifier
* `tools` - Array of tool names to enable
* `onInit` - Optional initialization hook
* `onAfterConnect` - Optional post-connection hook
* `onDisconnect` - Optional disconnect hook
Vercel AI SDK Integration [#vercel-ai-sdk-integration]
VercelAITool [#vercelaitool]
Tool definition compatible with Vercel AI SDK v5:
VercelAIToolsOptions [#vercelaitoolsoptions]
Options for converting MCP tools to Vercel AI SDK format:
getVercelAITools() [#getvercelaitools]
Converts all enabled MCP tools to Vercel AI SDK format.
```typescript
function getVercelAITools(
client: MCPClient,
options?: VercelAIToolsOptions
): Record;
```
**Parameters:**
* `client` - Connected MCP client
* `options` - Optional configuration (see VercelAIToolsOptions above)
**Returns:**
* Object mapping tool names to Vercel AI SDK tools
**Example:**
```typescript
// Client-side
const tools = await getVercelAITools(mcpClient);
// Server-side with provider tokens
const tools = await getVercelAITools(serverClient, {
providerTokens: { github: "ghp_...", gmail: "ya29..." },
});
const result = await generateText({
model: openai("gpt-4"),
prompt: "Create a GitHub issue",
tools,
});
```
convertMCPToolsToVercelAI() [#convertmcptoolstovercelai]
Alternative name for `getVercelAITools()`.
```typescript
function convertMCPToolsToVercelAI(client: MCPClient): Record;
```
convertMCPToolToVercelAI() [#convertmcptooltovercelai]
Converts a single MCP tool to Vercel AI SDK format.
```typescript
function convertMCPToolToVercelAI(tool: MCPTool, client: MCPClient): CoreTool;
```
**Parameters:**
* `tool` - MCP tool definition
* `client` - MCP client for execution
**Returns:**
* Tool in Vercel AI SDK format
**Example:**
```typescript
const tool = client.getTool("github_create_issue");
if (tool) {
const vercelTool = convertMCPToolToVercelAI(tool, client);
}
```
Constants [#constants]
Server URL [#server-url]
```typescript
const MCP_SERVER_URL = "https://mcp.integrate.dev/api/v1/mcp";
```
Default Timeout [#default-timeout]
```typescript
const DEFAULT_TIMEOUT = 30000; // 30 seconds
```
Error Types [#error-types]
The SDK provides specific error classes for different failure scenarios.
IntegrateSDKError [#integratesdkerror]
Base error class for all SDK errors.
```typescript
class IntegrateSDKError extends Error {
name: "IntegrateSDKError";
}
```
AuthenticationError [#authenticationerror]
Error thrown when authentication fails or tokens are invalid.
```typescript
class AuthenticationError extends IntegrateSDKError {
name: "AuthenticationError";
statusCode?: number; // HTTP status code (usually 401)
provider?: string; // OAuth provider name
}
```
**Example:**
```typescript
import { isAuthError, AuthenticationError } from "integrate-sdk";
try {
await client.github.createIssue({
owner: "user",
repo: "repo",
title: "Bug",
});
} catch (error) {
if (isAuthError(error)) {
console.error(`Auth failed for ${error.provider}: ${error.message}`);
}
}
```
TokenExpiredError [#tokenexpirederror]
Error thrown when OAuth tokens have expired.
```typescript
class TokenExpiredError extends AuthenticationError {
name: "TokenExpiredError";
provider?: string; // OAuth provider name
}
```
**Example:**
```typescript
import { isTokenExpiredError } from "integrate-sdk";
try {
await client.github.createIssue({
owner: "user",
repo: "repo",
title: "Bug",
});
} catch (error) {
if (isTokenExpiredError(error)) {
console.error(`Token expired for ${error.provider}`);
// Trigger re-authentication
}
}
```
AuthorizationError [#authorizationerror]
Error thrown when access is forbidden due to insufficient permissions.
```typescript
class AuthorizationError extends IntegrateSDKError {
name: "AuthorizationError";
statusCode?: number; // HTTP status code (usually 403)
requiredScopes?: string[]; // Missing OAuth scopes
}
```
**Example:**
```typescript
import { isAuthorizationError } from "integrate-sdk";
try {
await client.github.createIssue({
owner: "user",
repo: "repo",
title: "Bug",
});
} catch (error) {
if (isAuthorizationError(error)) {
console.error("Insufficient permissions");
if (error.requiredScopes) {
console.error("Required scopes:", error.requiredScopes);
}
}
}
```
ConnectionError [#connectionerror]
Error thrown when a connection to the server fails.
```typescript
class ConnectionError extends IntegrateSDKError {
name: "ConnectionError";
statusCode?: number; // HTTP status code
}
```
ToolCallError [#toolcallerror]
Error thrown when a tool call fails.
```typescript
class ToolCallError extends IntegrateSDKError {
name: "ToolCallError";
toolName: string; // Name of the tool that failed
originalError?: unknown; // Original error from server
}
```
Error Helper Functions [#error-helper-functions]
Type guard functions for error handling:
```typescript
// Check if error is any authentication error
function isAuthError(error: unknown): error is AuthenticationError;
// Check if error is specifically a token expired error
function isTokenExpiredError(error: unknown): error is TokenExpiredError;
// Check if error is an authorization error
function isAuthorizationError(error: unknown): error is AuthorizationError;
```
**Example:**
```typescript
import {
isAuthError,
isTokenExpiredError,
isAuthorizationError,
} from "integrate-sdk";
try {
await client.github.createIssue({
owner: "user",
repo: "repo",
title: "Bug",
});
} catch (error) {
if (isTokenExpiredError(error)) {
// Handle token expiration
} else if (isAuthError(error)) {
// Handle other auth errors
} else if (isAuthorizationError(error)) {
// Handle permission errors
} else {
// Handle other errors
}
}
```
parseServerError() [#parseservererror]
Utility function to parse server errors into appropriate error types.
```typescript
function parseServerError(
error: any,
context?: { toolName?: string; provider?: string }
): IntegrateSDKError;
```
This function is used internally by the SDK but can be useful for custom error handling.
Triggers [#triggers]
The Trigger API allows you to schedule tool executions for one-time or recurring jobs.
client.trigger.create() [#clienttriggercreate]
Create a new scheduled trigger.
```typescript
async create(params: CreateTriggerParams): Promise
```
**Parameters:**
**Returns:**
The created trigger with generated ID and metadata.
**Example:**
```typescript
// One-time trigger
const trigger = await client.trigger.create({
name: "Send Email",
toolName: "gmail_send_email",
toolArguments: { to: "user@example.com", subject: "Hello" },
schedule: { type: "once", runAt: new Date("2024-12-13T22:00:00Z") },
});
// Recurring trigger
const daily = await client.trigger.create({
name: "Daily Report",
toolName: "slack_send_message",
toolArguments: { channel: "#team", text: "Daily report" },
schedule: { type: "cron", expression: "0 9 * * *" },
});
```
client.trigger.list() [#clienttriggerlist]
List triggers with optional filters.
```typescript
async list(params?: ListTriggersParams): Promise
```
**Parameters:**
**Returns:**
**Example:**
```typescript
// Get all triggers
const { triggers, total } = await client.trigger.list();
// Get active triggers
const active = await client.trigger.list({ status: "active", limit: 10 });
// Filter by tool name
const emailTriggers = await client.trigger.list({
toolName: "gmail_send_email",
});
```
client.trigger.get() [#clienttriggerget]
Get a specific trigger by ID.
```typescript
async get(triggerId: string): Promise
```
**Parameters:**
* `triggerId` (string) - The trigger ID to retrieve
**Returns:**
The trigger details.
**Example:**
```typescript
const trigger = await client.trigger.get("trig_abc123");
console.log(trigger.status); // 'active'
console.log(trigger.nextRunAt); // '2024-12-13T22:00:00Z'
```
client.trigger.update() [#clienttriggerupdate]
Update an existing trigger.
```typescript
async update(triggerId: string, params: UpdateTriggerParams): Promise
```
**Parameters:**
* `triggerId` (string) - The trigger ID to update
* `params` (UpdateTriggerParams) - Partial trigger updates
**Returns:**
The updated trigger.
**Example:**
```typescript
// Update schedule
await client.trigger.update("trig_abc123", {
schedule: { type: "cron", expression: "0 10 * * *" },
});
// Update arguments
await client.trigger.update("trig_abc123", {
toolArguments: { channel: "#general" },
});
```
client.trigger.delete() [#clienttriggerdelete]
Delete a trigger permanently.
```typescript
async delete(triggerId: string): Promise
```
**Parameters:**
* `triggerId` (string) - The trigger ID to delete
**Example:**
```typescript
await client.trigger.delete("trig_abc123");
```
client.trigger.pause() [#clienttriggerpause]
Pause a trigger (stop future executions without deleting).
```typescript
async pause(triggerId: string): Promise
```
**Parameters:**
* `triggerId` (string) - The trigger ID to pause
**Returns:**
The updated trigger with status `'paused'`.
**Example:**
```typescript
const paused = await client.trigger.pause("trig_abc123");
console.log(paused.status); // 'paused'
```
client.trigger.resume() [#clienttriggerresume]
Resume a paused trigger.
```typescript
async resume(triggerId: string): Promise
```
**Parameters:**
* `triggerId` (string) - The trigger ID to resume
**Returns:**
The updated trigger with status `'active'`.
**Example:**
```typescript
const resumed = await client.trigger.resume("trig_abc123");
console.log(resumed.status); // 'active'
```
client.trigger.run() [#clienttriggerrun]
Execute a trigger immediately, bypassing the schedule.
```typescript
async run(triggerId: string): Promise
```
**Parameters:**
* `triggerId` (string) - The trigger ID to execute
**Returns:**
**Example:**
```typescript
const result = await client.trigger.run("trig_abc123");
if (result.success) {
console.log("Success:", result.result);
} else {
console.error("Failed:", result.error);
}
```
Trigger Type [#trigger-type]
TriggerSchedule Type [#triggerschedule-type]
```typescript
type TriggerSchedule =
| { type: "once"; runAt: string | Date }
| { type: "cron"; expression: string };
```
**One-time schedule:**
```typescript
{ type: 'once', runAt: new Date('2024-12-13T22:00:00Z') }
{ type: 'once', runAt: '2024-12-13T22:00:00Z' }
```
**Recurring schedule (cron):**
```typescript
{ type: 'cron', expression: '0 9 * * *' } // Daily at 9 AM
{ type: 'cron', expression: '0 9 * * 1-5' } // Weekdays at 9 AM
{ type: 'cron', expression: '0 */2 * * *' } // Every 2 hours
```
TriggerCallbacks [#triggercallbacks]
Database storage callbacks for server-side configuration:
**Example:**
```typescript
import { createMCPServer } from "integrate-sdk/server";
export const { client } = createMCPServer({
triggers: {
create: async (trigger, context) => {
return db.trigger.create({ data: trigger });
},
get: async (id, context) => {
return db.trigger.findFirst({ where: { id } });
},
list: async (params, context) => {
const triggers = await db.trigger.findMany({
where: { status: params.status },
take: params.limit,
});
return { triggers, total: triggers.length, hasMore: false };
},
update: async (id, updates, context) => {
return db.trigger.update({ where: { id }, data: updates });
},
delete: async (id, context) => {
await db.trigger.delete({ where: { id } });
},
},
});
```
Next Steps [#next-steps]
* Explore [Advanced Usage](/docs/getting-started/advanced-usage) for patterns and techniques
* See example code in the repository
# Adobe Acrobat Sign Integration
The Adobe Acrobat Sign integration provides access to manage Adobe Acrobat Sign get user, list agreements, get agreement, create agreement, list library documents through the Integrate MCP server.
Installation [#installation]
The Adobe Acrobat Sign integration is included with the SDK:
```typescript
import { adobeAcrobatSignIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Adobe Acrobat Sign OAuth App [#1-create-an-adobe-acrobat-sign-oauth-app]
1. Create an OAuth application for Adobe Acrobat Sign
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Adobe Acrobat Sign integration to your server configuration. The integration automatically reads `ADOBE_ACROBAT_SIGN_CLIENT_ID` and `ADOBE_ACROBAT_SIGN_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, adobeAcrobatSignIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
adobeAcrobatSignIntegration({
scopes: ["user_read", "agreement_read", "agreement_write", "library_read", "library_write"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
adobeAcrobatSignIntegration({
clientId: process.env.CUSTOM_ADOBE_ACROBAT_SIGN_ID,
clientSecret: process.env.CUSTOM_ADOBE_ACROBAT_SIGN_SECRET,
scopes: ["user_read", "agreement_read", "agreement_write", "library_read", "library_write"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("adobe_acrobat_sign");
const result = await client.adobe_acrobat_sign.getUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, adobeAcrobatSignIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [adobeAcrobatSignIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `user_read`
* `agreement_read`
* `agreement_write`
* `library_read`
* `library_write`
Tools [#tools]
adobe_acrobat_sign_get_user [#adobe_acrobat_sign_get_user]
Acrobat sign get user
*No parameters.*
adobe_acrobat_sign_list_agreements [#adobe_acrobat_sign_list_agreements]
Acrobat sign list agreements
adobe_acrobat_sign_get_agreement [#adobe_acrobat_sign_get_agreement]
Acrobat sign get agreement
adobe_acrobat_sign_create_agreement [#adobe_acrobat_sign_create_agreement]
Acrobat sign create agreement
adobe_acrobat_sign_list_library_documents [#adobe_acrobat_sign_list_library_documents]
Acrobat sign list library documents
adobe_acrobat_sign_get_signing_urls [#adobe_acrobat_sign_get_signing_urls]
Acrobat sign get signing urls
Notes [#notes]
* Category: Legal
* Authentication mode: OAuth
# Airtable Integration
The Airtable integration provides access to manage Airtable bases, tables, and records through the Integrate MCP server.
Installation [#installation]
The Airtable integration is included with the SDK:
```typescript
import { airtableIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Airtable OAuth App [#1-create-an-airtable-oauth-app]
1. Go to [Airtable Developer Hub](https://airtable.com/create/oauth)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Airtable integration to your server configuration. The integration automatically reads `AIRTABLE_CLIENT_ID` and `AIRTABLE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, airtableIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
airtableIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
airtableIntegration({
clientId: process.env.CUSTOM_AIRTABLE_ID,
clientSecret: process.env.CUSTOM_AIRTABLE_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("airtable");
const result = await client.airtable.listBases({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, airtableIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [airtableIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
airtable_list_bases [#airtable_list_bases]
List all accessible bases
airtable_get_base [#airtable_get_base]
Get a specific base
airtable_list_tables [#airtable_list_tables]
List tables in a base
airtable_get_table [#airtable_get_table]
Get a specific table schema
airtable_list_records [#airtable_list_records]
List records in a table
airtable_get_record [#airtable_get_record]
Get a specific record
airtable_create_record [#airtable_create_record]
Create a new record
airtable_update_record [#airtable_update_record]
Update an existing record
airtable_search_records [#airtable_search_records]
Search for records using a formula
airtable_delete_record [#airtable_delete_record]
Delete a record
airtable_create_base [#airtable_create_base]
Create a new base
airtable_create_table [#airtable_create_table]
Create a new table in a base
airtable_update_table [#airtable_update_table]
Update a table's name or description
airtable_create_field [#airtable_create_field]
Create a new field in a table
airtable_update_field [#airtable_update_field]
Update a field's name or description
airtable_list_comments [#airtable_list_comments]
List comments on a record
airtable_create_comment [#airtable_create_comment]
Create a comment on a record
airtable_update_comment [#airtable_update_comment]
Update a comment
airtable_delete_comment [#airtable_delete_comment]
Delete a comment
airtable_list_webhooks [#airtable_list_webhooks]
List webhooks for a base
airtable_create_webhook [#airtable_create_webhook]
Create a webhook for a base
airtable_delete_webhook [#airtable_delete_webhook]
Delete a webhook
airtable_list_webhook_payloads [#airtable_list_webhook_payloads]
List webhook payloads
airtable_refresh_webhook [#airtable_refresh_webhook]
Refresh a webhook to extend its expiration
Notes [#notes]
* Category: Business
* Authentication mode: OAuth
# Alpaca Integration
The Alpaca integration provides access to trade US equities and crypto with Alpaca: account, orders, positions, clock, and assets through the Integrate MCP server.
Installation [#installation]
The Alpaca integration is included with the SDK:
```typescript
import { alpacaIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Alpaca to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, alpacaIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
alpacaIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.alpaca.getAccount({});
console.log(result);
```
Environment Variables [#environment-variables]
* `ALPACA_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
alpaca_get_account [#alpaca_get_account]
Get account
*No parameters.*
alpaca_list_positions [#alpaca_list_positions]
List positions
*No parameters.*
alpaca_get_position [#alpaca_get_position]
Get position
alpaca_list_orders [#alpaca_list_orders]
List orders
alpaca_get_order [#alpaca_get_order]
Get order
alpaca_create_order [#alpaca_create_order]
Create order
alpaca_cancel_order [#alpaca_cancel_order]
Cancel order
alpaca_cancel_all_orders [#alpaca_cancel_all_orders]
Cancel all orders
alpaca_get_clock [#alpaca_get_clock]
Get clock
*No parameters.*
alpaca_get_calendar [#alpaca_get_calendar]
Get calendar
alpaca_list_assets [#alpaca_list_assets]
List assets
alpaca_get_asset [#alpaca_get_asset]
Get asset
alpaca_get_portfolio_history [#alpaca_get_portfolio_history]
Get portfolio history
Notes [#notes]
* Category: Finance
* Authentication mode: API key
# Amadeus Integration
The Amadeus integration provides access to manage Amadeus search flights, price flight, search hotels, get hotel offers, search locations through the Integrate MCP server.
Installation [#installation]
The Amadeus integration is included with the SDK:
```typescript
import { amadeusIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Amadeus OAuth App [#1-create-an-amadeus-oauth-app]
1. Create an OAuth application for Amadeus
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Amadeus integration to your server configuration. The integration automatically reads `AMADEUS_CLIENT_ID` and `AMADEUS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, amadeusIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
amadeusIntegration({
scopes: ["travel"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
amadeusIntegration({
clientId: process.env.CUSTOM_AMADEUS_ID,
clientSecret: process.env.CUSTOM_AMADEUS_SECRET,
scopes: ["travel"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("amadeus");
const result = await client.amadeus.searchFlights({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, amadeusIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [amadeusIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `travel`
Tools [#tools]
amadeus_search_flights [#amadeus_search_flights]
Search flights
amadeus_price_flight [#amadeus_price_flight]
Price flight
amadeus_search_hotels [#amadeus_search_hotels]
Search hotels
amadeus_get_hotel_offers [#amadeus_get_hotel_offers]
Get hotel offers
amadeus_search_locations [#amadeus_search_locations]
Search locations
Notes [#notes]
* Category: Travel
* Authentication mode: OAuth
# Amazon Selling Partner Integration
The Amazon Selling Partner integration provides access to manage Amazon Selling Partner search catalog items, list orders, get order, list inventory, list listings through the Integrate MCP server.
Installation [#installation]
The Amazon Selling Partner integration is included with the SDK:
```typescript
import { amazonIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Amazon Selling Partner OAuth App [#1-create-an-amazon-selling-partner-oauth-app]
1. Create an OAuth application for Amazon Selling Partner
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Amazon Selling Partner integration to your server configuration. The integration automatically reads `AMAZON_CLIENT_ID` and `AMAZON_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, amazonIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
amazonIntegration({
scopes: ["sellingpartnerapi::notifications", "sellingpartnerapi::migration"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
amazonIntegration({
clientId: process.env.CUSTOM_AMAZON_ID,
clientSecret: process.env.CUSTOM_AMAZON_SECRET,
scopes: ["sellingpartnerapi::notifications", "sellingpartnerapi::migration"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("amazon");
const result = await client.amazon.searchCatalogItems({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, amazonIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [amazonIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `sellingpartnerapi::notifications`
* `sellingpartnerapi::migration`
Tools [#tools]
amazon_search_catalog_items [#amazon_search_catalog_items]
Search catalog items
amazon_list_orders [#amazon_list_orders]
List orders
amazon_get_order [#amazon_get_order]
Get order
amazon_list_inventory [#amazon_list_inventory]
List inventory
amazon_list_listings [#amazon_list_listings]
List listings
amazon_patch_listing [#amazon_patch_listing]
Patch listing
Notes [#notes]
* Category: Commerce
* Authentication mode: OAuth
# Amazon Ads Integration
The Amazon Ads integration provides access to manage Amazon Ads list profiles, list campaigns, create campaigns, list ad groups, list keywords through the Integrate MCP server.
Installation [#installation]
The Amazon Ads integration is included with the SDK:
```typescript
import { amazonAdsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Amazon Ads OAuth App [#1-create-an-amazon-ads-oauth-app]
1. Create an OAuth application for Amazon Ads
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Amazon Ads integration to your server configuration. The integration automatically reads `AMAZON_ADS_CLIENT_ID` and `AMAZON_ADS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, amazonAdsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
amazonAdsIntegration({
scopes: ["advertising::campaign_management"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
amazonAdsIntegration({
clientId: process.env.CUSTOM_AMAZON_ADS_ID,
clientSecret: process.env.CUSTOM_AMAZON_ADS_SECRET,
scopes: ["advertising::campaign_management"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("amazon_ads");
const result = await client.amazon_ads.listProfiles({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, amazonAdsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [amazonAdsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `advertising::campaign_management`
Tools [#tools]
amazon_ads_list_profiles [#amazon_ads_list_profiles]
Ads list profiles
*No parameters.*
amazon_ads_list_campaigns [#amazon_ads_list_campaigns]
Ads list campaigns
amazon_ads_create_campaigns [#amazon_ads_create_campaigns]
Ads create campaigns
amazon_ads_list_ad_groups [#amazon_ads_list_ad_groups]
Ads list ad groups
amazon_ads_list_keywords [#amazon_ads_list_keywords]
Ads list keywords
amazon_ads_request_report [#amazon_ads_request_report]
Ads request report
Notes [#notes]
* Category: Marketing
* Authentication mode: OAuth
# Asana Integration
The Asana integration provides access to manage Asana workspaces, projects, sections, tasks, stories, users, and teams through the Integrate MCP server.
Installation [#installation]
The Asana integration is included with the SDK:
```typescript
import { asanaIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Asana OAuth App [#1-create-an-asana-oauth-app]
1. Create an OAuth application for Asana
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Asana integration to your server configuration. The integration automatically reads `ASANA_CLIENT_ID` and `ASANA_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, asanaIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
asanaIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
asanaIntegration({
clientId: process.env.CUSTOM_ASANA_ID,
clientSecret: process.env.CUSTOM_ASANA_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("asana");
const result = await client.asana.getCurrentUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, asanaIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [asanaIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
asana_get_current_user [#asana_get_current_user]
Get current user
*No parameters.*
asana_list_workspaces [#asana_list_workspaces]
List workspaces
asana_list_projects [#asana_list_projects]
List projects
asana_get_project [#asana_get_project]
Get project
asana_create_project [#asana_create_project]
Create project
asana_update_project [#asana_update_project]
Update project
asana_list_sections [#asana_list_sections]
List sections
asana_list_tasks [#asana_list_tasks]
List tasks
asana_get_task [#asana_get_task]
Get task
asana_create_task [#asana_create_task]
Create task
asana_update_task [#asana_update_task]
Update task
asana_delete_task [#asana_delete_task]
Delete task
asana_list_stories [#asana_list_stories]
List stories
asana_create_story [#asana_create_story]
Create story
asana_list_users [#asana_list_users]
List users
asana_list_teams [#asana_list_teams]
List teams
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Astronomer Integration
The Astronomer integration provides access to manage Astro organizations, workspaces, deployments, clusters, and deploy history via the Astro API v1 through the Integrate MCP server.
Installation [#installation]
The Astronomer integration is included with the SDK:
```typescript
import { astronomerIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Astronomer to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, astronomerIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
astronomerIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.astronomer.getSelf({});
console.log(result);
```
Environment Variables [#environment-variables]
* `ASTRONOMER_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
astronomer_get_self [#astronomer_get_self]
Get self
astronomer_list_organizations [#astronomer_list_organizations]
List organizations
astronomer_get_organization [#astronomer_get_organization]
Get organization
astronomer_list_workspaces [#astronomer_list_workspaces]
List workspaces
astronomer_get_workspace [#astronomer_get_workspace]
Get workspace
astronomer_list_clusters [#astronomer_list_clusters]
List clusters
astronomer_get_cluster [#astronomer_get_cluster]
Get cluster
astronomer_list_deployments [#astronomer_list_deployments]
List deployments
astronomer_get_deployment [#astronomer_get_deployment]
Get deployment
astronomer_create_deployment [#astronomer_create_deployment]
Create deployment
astronomer_update_deployment [#astronomer_update_deployment]
Update deployment
astronomer_list_deploys [#astronomer_list_deploys]
List deploys
astronomer_get_deploy [#astronomer_get_deploy]
Get deploy
Notes [#notes]
* Category: Engineering
* Authentication mode: API key
# Attio Integration
The Attio integration provides access to manage Attio people, companies, records, and tasks through the Integrate MCP server.
Installation [#installation]
The Attio integration is included with the SDK:
```typescript
import { attioIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Attio OAuth App [#1-create-an-attio-oauth-app]
1. Go to [App Developer Portal](https://app.attio.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Attio integration to your server configuration. The integration automatically reads `ATTIO_CLIENT_ID` and `ATTIO_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, attioIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
attioIntegration({
scopes: ["record_permission:read-write", "object_configuration:read", "user_management:read", "task:read"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
attioIntegration({
clientId: process.env.CUSTOM_ATTIO_ID,
clientSecret: process.env.CUSTOM_ATTIO_SECRET,
scopes: ["record_permission:read-write", "object_configuration:read", "user_management:read", "task:read"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("attio");
const result = await client.attio.getSelf({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, attioIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [attioIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `record_permission:read-write`
* `object_configuration:read`
* `user_management:read`
* `task:read`
Tools [#tools]
attio_get_self [#attio_get_self]
Get self
*No parameters.*
attio_query_people [#attio_query_people]
Query people
attio_get_person [#attio_get_person]
Get person
attio_create_person [#attio_create_person]
Create person
attio_update_person [#attio_update_person]
Update person
attio_assert_person [#attio_assert_person]
Assert person
attio_query_companies [#attio_query_companies]
Query companies
attio_get_company [#attio_get_company]
Get company
attio_create_company [#attio_create_company]
Create company
attio_update_company [#attio_update_company]
Update company
attio_assert_company [#attio_assert_company]
Assert company
attio_list_tasks [#attio_list_tasks]
List tasks
attio_get_task [#attio_get_task]
Get task
Notes [#notes]
* Category: Business
* Authentication mode: OAuth
# Auth0 Integration
The Auth0 integration provides access to manage Auth0 users, applications, and tenant configuration through the Integrate MCP server.
Installation [#installation]
The Auth0 integration is included with the SDK:
```typescript
import { auth0Integration } from "integrate-sdk/server";
```
Setup [#setup]
Add Auth0 to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, auth0Integration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
auth0Integration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.auth0.listUsers({});
console.log(result);
```
Environment Variables [#environment-variables]
* `AUTH0_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
auth0_list_users [#auth0_list_users]
List users
auth0_get_user [#auth0_get_user]
Get user
auth0_create_user [#auth0_create_user]
Create user
auth0_patch_user [#auth0_patch_user]
Patch user
auth0_delete_user [#auth0_delete_user]
Delete user
auth0_list_connections [#auth0_list_connections]
List connections
auth0_get_connection [#auth0_get_connection]
Get connection
auth0_list_clients [#auth0_list_clients]
List clients
auth0_get_client [#auth0_get_client]
Get client
auth0_create_client [#auth0_create_client]
Create client
auth0_patch_client [#auth0_patch_client]
Patch client
Notes [#notes]
* Category: Identity & Access
* Authentication mode: API key
# Amazon Web Services Integration
The Amazon Web Services integration provides access to query AWS accounts and resources using SigV4 (control-plane read APIs: STS, EC2, S3, Lambda, CloudFormation, IAM). through the Integrate MCP server.
Installation [#installation]
The Amazon Web Services integration is included with the SDK:
```typescript
import { awsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Amazon Web Services to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, awsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
awsIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.aws.stsGetCallerIdentity({});
console.log(result);
```
Environment Variables [#environment-variables]
* `AWS_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
aws_sts_get_caller_identity [#aws_sts_get_caller_identity]
Sts get caller identity
*No parameters.*
aws_ec2_describe_regions [#aws_ec2_describe_regions]
Ec2 describe regions
aws_ec2_describe_instances [#aws_ec2_describe_instances]
Ec2 describe instances
aws_s3_list_buckets [#aws_s3_list_buckets]
S3 list buckets
*No parameters.*
aws_lambda_list_functions [#aws_lambda_list_functions]
Lambda list functions
aws_cloudformation_list_stacks [#aws_cloudformation_list_stacks]
Cloudformation list stacks
aws_iam_list_account_aliases [#aws_iam_list_account_aliases]
Iam list account aliases
*No parameters.*
Notes [#notes]
* Category: Infrastructure
* Authentication mode: API key
# Azure DevOps Integration
The Azure DevOps integration provides access to manage Azure DevOps projects, repositories, pull requests, builds, and work items through the Integrate MCP server.
Installation [#installation]
The Azure DevOps integration is included with the SDK:
```typescript
import { azureDevopsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Azure DevOps OAuth App [#1-create-an-azure-devops-oauth-app]
1. Create an OAuth application for Azure DevOps
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Azure DevOps integration to your server configuration. The integration automatically reads `AZURE_DEVOPS_CLIENT_ID` and `AZURE_DEVOPS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, azureDevopsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
azureDevopsIntegration({
scopes: ["vso.profile", "vso.project", "vso.code_write", "vso.build", "vso.work_write"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
azureDevopsIntegration({
clientId: process.env.CUSTOM_AZURE_DEVOPS_ID,
clientSecret: process.env.CUSTOM_AZURE_DEVOPS_SECRET,
scopes: ["vso.profile", "vso.project", "vso.code_write", "vso.build", "vso.work_write"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("azure_devops");
const result = await client.azure_devops.listProjects({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, azureDevopsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [azureDevopsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `vso.profile`
* `vso.project`
* `vso.code_write`
* `vso.build`
* `vso.work_write`
Tools [#tools]
azure_devops_list_projects [#azure_devops_list_projects]
Devops list projects
azure_devops_list_repositories [#azure_devops_list_repositories]
Devops list repositories
azure_devops_list_pull_requests [#azure_devops_list_pull_requests]
Devops list pull requests
azure_devops_list_builds [#azure_devops_list_builds]
Devops list builds
azure_devops_queue_build [#azure_devops_queue_build]
Devops queue build
azure_devops_get_work_item [#azure_devops_get_work_item]
Devops get work item
Notes [#notes]
* Category: Engineering
* Authentication mode: OAuth
# BambooHR Integration
The BambooHR integration provides access to manage BambooHR get company report, list employees, get employee, update employee, list time off requests through the Integrate MCP server.
Installation [#installation]
The BambooHR integration is included with the SDK:
```typescript
import { bamboohrIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a BambooHR OAuth App [#1-create-a-bamboohr-oauth-app]
1. Create an OAuth application for BambooHR
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the BambooHR integration to your server configuration. The integration automatically reads `BAMBOOHR_CLIENT_ID` and `BAMBOOHR_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, bamboohrIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
bamboohrIntegration({
scopes: ["employee.read", "employee.write", "time_off.read", "time_off.write"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
bamboohrIntegration({
clientId: process.env.CUSTOM_BAMBOOHR_ID,
clientSecret: process.env.CUSTOM_BAMBOOHR_SECRET,
scopes: ["employee.read", "employee.write", "time_off.read", "time_off.write"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("bamboohr");
const result = await client.bamboohr.getCompanyReport({
report_json: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, bamboohrIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [bamboohrIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `employee.read`
* `employee.write`
* `time_off.read`
* `time_off.write`
Tools [#tools]
bamboohr_get_company_report [#bamboohr_get_company_report]
Get company report
bamboohr_list_employees [#bamboohr_list_employees]
List employees
bamboohr_get_employee [#bamboohr_get_employee]
Get employee
bamboohr_update_employee [#bamboohr_update_employee]
Update employee
bamboohr_list_time_off_requests [#bamboohr_list_time_off_requests]
List time off requests
bamboohr_create_time_off_request [#bamboohr_create_time_off_request]
Create time off request
Notes [#notes]
* Category: HR & Recruiting
* Authentication mode: OAuth
# Better Stack Integration
The Better Stack integration provides access to ingest and manage log sources, collectors, and metrics with Better Stack Logs (Logtail) Telemetry API through the Integrate MCP server.
Installation [#installation]
The Better Stack integration is included with the SDK:
```typescript
import { betterstackIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Better Stack to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, betterstackIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
betterstackIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.betterstack.listSources({});
console.log(result);
```
Environment Variables [#environment-variables]
* `BETTERSTACK_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
betterstack_list_sources [#betterstack_list_sources]
List sources
betterstack_get_source [#betterstack_get_source]
Get source
betterstack_create_source [#betterstack_create_source]
Create source
betterstack_update_source [#betterstack_update_source]
Update source
betterstack_delete_source [#betterstack_delete_source]
Delete source
betterstack_list_source_groups [#betterstack_list_source_groups]
List source groups
betterstack_get_source_group [#betterstack_get_source_group]
Get source group
betterstack_update_source_group [#betterstack_update_source_group]
Update source group
betterstack_list_collectors [#betterstack_list_collectors]
List collectors
betterstack_list_source_metrics [#betterstack_list_source_metrics]
List source metrics
betterstack_ingest_logs [#betterstack_ingest_logs]
Ingest logs
Notes [#notes]
* Category: Engineering
* Authentication mode: API key
# BigCommerce Integration
The BigCommerce integration provides access to manage BigCommerce list products, get product, create product, list orders, get order through the Integrate MCP server.
Installation [#installation]
The BigCommerce integration is included with the SDK:
```typescript
import { bigcommerceIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a BigCommerce OAuth App [#1-create-a-bigcommerce-oauth-app]
1. Create an OAuth application for BigCommerce
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the BigCommerce integration to your server configuration. The integration automatically reads `BIGCOMMERCE_CLIENT_ID` and `BIGCOMMERCE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, bigcommerceIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
bigcommerceIntegration({
scopes: ["store_v2_products", "store_v2_orders", "store_v2_customers", "store_v2_information"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
bigcommerceIntegration({
clientId: process.env.CUSTOM_BIGCOMMERCE_ID,
clientSecret: process.env.CUSTOM_BIGCOMMERCE_SECRET,
scopes: ["store_v2_products", "store_v2_orders", "store_v2_customers", "store_v2_information"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("bigcommerce");
const result = await client.bigcommerce.listProducts({
store_hash: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, bigcommerceIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [bigcommerceIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `store_v2_products`
* `store_v2_orders`
* `store_v2_customers`
* `store_v2_information`
Tools [#tools]
bigcommerce_list_products [#bigcommerce_list_products]
List products
bigcommerce_get_product [#bigcommerce_get_product]
Get product
bigcommerce_create_product [#bigcommerce_create_product]
Create product
bigcommerce_list_orders [#bigcommerce_list_orders]
List orders
bigcommerce_get_order [#bigcommerce_get_order]
Get order
bigcommerce_list_customers [#bigcommerce_list_customers]
List customers
Notes [#notes]
* Category: Commerce
* Authentication mode: OAuth
# BigQuery Integration
The BigQuery integration provides access to manage BigQuery list projects, list datasets, list tables, get table, query through the Integrate MCP server.
Installation [#installation]
The BigQuery integration is included with the SDK:
```typescript
import { bigqueryIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a BigQuery OAuth App [#1-create-a-bigquery-oauth-app]
1. Create an OAuth application for BigQuery
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the BigQuery integration to your server configuration. The integration automatically reads `BIGQUERY_CLIENT_ID` and `BIGQUERY_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, bigqueryIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
bigqueryIntegration({
scopes: ["https://www.googleapis.com/auth/bigquery", "https://www.googleapis.com/auth/cloud-platform"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
bigqueryIntegration({
clientId: process.env.CUSTOM_BIGQUERY_ID,
clientSecret: process.env.CUSTOM_BIGQUERY_SECRET,
scopes: ["https://www.googleapis.com/auth/bigquery", "https://www.googleapis.com/auth/cloud-platform"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("bigquery");
const result = await client.bigquery.listProjects({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, bigqueryIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [bigqueryIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `https://www.googleapis.com/auth/bigquery`
* `https://www.googleapis.com/auth/cloud-platform`
Tools [#tools]
bigquery_list_projects [#bigquery_list_projects]
List projects
bigquery_list_datasets [#bigquery_list_datasets]
List datasets
bigquery_list_tables [#bigquery_list_tables]
List tables
bigquery_get_table [#bigquery_get_table]
Get table
bigquery_query [#bigquery_query]
Query
bigquery_list_jobs [#bigquery_list_jobs]
List jobs
Notes [#notes]
* Category: Data & BI
* Authentication mode: OAuth
# Binance Integration
The Binance integration provides access to read Binance Spot market data and account information with API keys scoped to reading only through the Integrate MCP server.
Installation [#installation]
The Binance integration is included with the SDK:
```typescript
import { binanceIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Binance to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, binanceIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
binanceIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.binance.ping({});
console.log(result);
```
Environment Variables [#environment-variables]
* `BINANCE_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
binance_ping [#binance_ping]
Ping
*No parameters.*
binance_get_server_time [#binance_get_server_time]
Get server time
*No parameters.*
binance_get_exchange_info [#binance_get_exchange_info]
Get exchange info
binance_get_ticker_price [#binance_get_ticker_price]
Get ticker price
binance_get_ticker_24hr [#binance_get_ticker_24hr]
Get ticker 24hr
*No parameters.*
binance_get_order_book [#binance_get_order_book]
Get order book
binance_get_recent_trades [#binance_get_recent_trades]
Get recent trades
binance_get_klines [#binance_get_klines]
Get klines
binance_get_account [#binance_get_account]
Get account
*No parameters.*
binance_get_open_orders [#binance_get_open_orders]
Get open orders
binance_get_all_orders [#binance_get_all_orders]
Get all orders
binance_get_my_trades [#binance_get_my_trades]
Get my trades
Notes [#notes]
* Category: Finance
* Authentication mode: API key
# Bitbucket Cloud Integration
The Bitbucket Cloud integration provides access to manage Bitbucket Cloud workspaces, repositories, branches, commits, pull requests, issues, and pipelines through the Integrate MCP server.
Installation [#installation]
The Bitbucket Cloud integration is included with the SDK:
```typescript
import { bitbucketIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Bitbucket Cloud OAuth App [#1-create-a-bitbucket-cloud-oauth-app]
1. Create an OAuth application for Bitbucket Cloud
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Bitbucket Cloud integration to your server configuration. The integration automatically reads `BITBUCKET_CLIENT_ID` and `BITBUCKET_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, bitbucketIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
bitbucketIntegration({
scopes: ["account", "repository", "pullrequest", "issue", "pipeline"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
bitbucketIntegration({
clientId: process.env.CUSTOM_BITBUCKET_ID,
clientSecret: process.env.CUSTOM_BITBUCKET_SECRET,
scopes: ["account", "repository", "pullrequest", "issue", "pipeline"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("bitbucket");
const result = await client.bitbucket.getCurrentUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, bitbucketIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [bitbucketIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `account`
* `repository`
* `pullrequest`
* `issue`
* `pipeline`
Tools [#tools]
bitbucket_get_current_user [#bitbucket_get_current_user]
Get current user
*No parameters.*
bitbucket_list_workspaces [#bitbucket_list_workspaces]
List workspaces
bitbucket_list_repositories [#bitbucket_list_repositories]
List repositories
bitbucket_get_repository [#bitbucket_get_repository]
Get repository
bitbucket_list_branches [#bitbucket_list_branches]
List branches
bitbucket_list_commits [#bitbucket_list_commits]
List commits
bitbucket_get_commit [#bitbucket_get_commit]
Get commit
bitbucket_list_pull_requests [#bitbucket_list_pull_requests]
List pull requests
bitbucket_get_pull_request [#bitbucket_get_pull_request]
Get pull request
bitbucket_create_pull_request [#bitbucket_create_pull_request]
Create pull request
bitbucket_list_issues [#bitbucket_list_issues]
List issues
bitbucket_get_issue [#bitbucket_get_issue]
Get issue
bitbucket_create_issue [#bitbucket_create_issue]
Create issue
bitbucket_list_pipelines [#bitbucket_list_pipelines]
List pipelines
bitbucket_trigger_pipeline [#bitbucket_trigger_pipeline]
Trigger pipeline
Notes [#notes]
* Category: Engineering
* Authentication mode: OAuth
# Box Integration
The Box integration provides access to manage Box files, folders, sharing, comments, search, and collaborations through the Integrate MCP server.
Installation [#installation]
The Box integration is included with the SDK:
```typescript
import { boxIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Box OAuth App [#1-create-a-box-oauth-app]
1. Create an OAuth application for Box
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Box integration to your server configuration. The integration automatically reads `BOX_CLIENT_ID` and `BOX_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, boxIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
boxIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
boxIntegration({
clientId: process.env.CUSTOM_BOX_ID,
clientSecret: process.env.CUSTOM_BOX_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("box");
const result = await client.box.getCurrentUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, boxIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [boxIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
box_get_current_user [#box_get_current_user]
Get current user
*No parameters.*
box_list_folder_items [#box_list_folder_items]
List folder items
box_get_file [#box_get_file]
Get file
box_get_folder [#box_get_folder]
Get folder
box_create_folder [#box_create_folder]
Create folder
box_update_file [#box_update_file]
Update file
box_update_folder [#box_update_folder]
Update folder
box_delete_file [#box_delete_file]
Delete file
box_delete_folder [#box_delete_folder]
Delete folder
box_upload_text_file [#box_upload_text_file]
Upload text file
box_download_file [#box_download_file]
Download file
box_search [#box_search]
Search
box_create_shared_link [#box_create_shared_link]
Create shared link
box_create_collaboration [#box_create_collaboration]
Create collaboration
box_list_comments [#box_list_comments]
List comments
box_create_comment [#box_create_comment]
Create comment
box_delete_comment [#box_delete_comment]
Delete comment
Notes [#notes]
* Category: Storage
* Authentication mode: OAuth
# Cal.com Integration
The Cal.com integration provides access to manage Cal.com bookings and schedules through the Integrate MCP server.
Installation [#installation]
The Cal.com integration is included with the SDK:
```typescript
import { calcomIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Cal.com OAuth App [#1-create-a-calcom-oauth-app]
1. Go to [Cal.com Platform Settings](https://app.cal.com/settings/developer)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Cal.com integration to your server configuration. The integration automatically reads `CALCOM_CLIENT_ID` and `CALCOM_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, calcomIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
calcomIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
calcomIntegration({
clientId: process.env.CUSTOM_CALCOM_ID,
clientSecret: process.env.CUSTOM_CALCOM_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("calcom");
const result = await client.calcom.listBookings({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, calcomIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [calcomIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
calcom_list_bookings [#calcom_list_bookings]
List all bookings
calcom_get_booking [#calcom_get_booking]
Get booking details
calcom_create_booking [#calcom_create_booking]
Create a new booking
calcom_cancel_booking [#calcom_cancel_booking]
Cancel a booking
calcom_reschedule_booking [#calcom_reschedule_booking]
Reschedule a booking
calcom_update_booking [#calcom_update_booking]
Update an existing booking
calcom_get_booking_recordings [#calcom_get_booking_recordings]
Get recordings for a booking
calcom_get_booking_transcripts [#calcom_get_booking_transcripts]
Get transcripts for a booking
calcom_list_event_types [#calcom_list_event_types]
List event types
calcom_get_event_type [#calcom_get_event_type]
Get a specific event type
calcom_create_event_type [#calcom_create_event_type]
Create a new event type
calcom_update_event_type [#calcom_update_event_type]
Update an event type
calcom_delete_event_type [#calcom_delete_event_type]
Delete an event type
calcom_list_team_event_types [#calcom_list_team_event_types]
List event types for a team
calcom_get_availability [#calcom_get_availability]
Get availability slots
calcom_get_availability_rule [#calcom_get_availability_rule]
Get an availability rule
calcom_create_availability_rule [#calcom_create_availability_rule]
Create an availability rule
calcom_update_availability_rule [#calcom_update_availability_rule]
Update an availability rule
calcom_delete_availability_rule [#calcom_delete_availability_rule]
Delete an availability rule
calcom_list_schedules [#calcom_list_schedules]
List schedules
calcom_get_schedule [#calcom_get_schedule]
Get a specific schedule
calcom_create_schedule [#calcom_create_schedule]
Create a new schedule
calcom_update_schedule [#calcom_update_schedule]
Update a schedule
calcom_delete_schedule [#calcom_delete_schedule]
Delete a schedule
calcom_get_slots [#calcom_get_slots]
Get available time slots
calcom_list_attendees [#calcom_list_attendees]
List attendees
*No parameters.*
calcom_get_attendee [#calcom_get_attendee]
Get a specific attendee
calcom_create_attendee [#calcom_create_attendee]
Create a new attendee
calcom_update_attendee [#calcom_update_attendee]
Update an attendee
calcom_delete_attendee [#calcom_delete_attendee]
Delete an attendee
calcom_list_teams [#calcom_list_teams]
List teams
*No parameters.*
calcom_get_team [#calcom_get_team]
Get a specific team
calcom_create_team [#calcom_create_team]
Create a new team
calcom_update_team [#calcom_update_team]
Update a team
calcom_delete_team [#calcom_delete_team]
Delete a team
calcom_list_memberships [#calcom_list_memberships]
List memberships
*No parameters.*
calcom_get_membership [#calcom_get_membership]
Get a specific membership
calcom_create_membership [#calcom_create_membership]
Create a membership
calcom_update_membership [#calcom_update_membership]
Update a membership
calcom_delete_membership [#calcom_delete_membership]
Delete a membership
calcom_list_webhooks [#calcom_list_webhooks]
List webhooks
*No parameters.*
calcom_get_webhook [#calcom_get_webhook]
Get a specific webhook
calcom_create_webhook [#calcom_create_webhook]
Create a webhook
calcom_update_webhook [#calcom_update_webhook]
Update a webhook
calcom_delete_webhook [#calcom_delete_webhook]
Delete a webhook
calcom_list_payments [#calcom_list_payments]
List payments
*No parameters.*
calcom_get_payment [#calcom_get_payment]
Get a specific payment
calcom_list_users [#calcom_list_users]
List users
*No parameters.*
calcom_get_user [#calcom_get_user]
Get a specific user
calcom_create_user [#calcom_create_user]
Create a new user
calcom_update_user [#calcom_update_user]
Update a user
calcom_delete_user [#calcom_delete_user]
Delete a user
calcom_get_me [#calcom_get_me]
Get current user info
*No parameters.*
Notes [#notes]
* Category: Scheduling
* Authentication mode: OAuth
# Calendly Integration
The Calendly integration provides access to manage Calendly user profiles, event types, scheduled events, invitees, and availability schedules through the Integrate MCP server.
Installation [#installation]
The Calendly integration is included with the SDK:
```typescript
import { calendlyIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Calendly OAuth App [#1-create-a-calendly-oauth-app]
1. Create an OAuth application for Calendly
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Calendly integration to your server configuration. The integration automatically reads `CALENDLY_CLIENT_ID` and `CALENDLY_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, calendlyIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
calendlyIntegration({
scopes: ["user:read", "event_types:read", "scheduled_events:read", "organization_memberships:read", "routing:read"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
calendlyIntegration({
clientId: process.env.CUSTOM_CALENDLY_ID,
clientSecret: process.env.CUSTOM_CALENDLY_SECRET,
scopes: ["user:read", "event_types:read", "scheduled_events:read", "organization_memberships:read", "routing:read"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("calendly");
const result = await client.calendly.getCurrentUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, calendlyIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [calendlyIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `user:read`
* `event_types:read`
* `scheduled_events:read`
* `organization_memberships:read`
* `routing:read`
Tools [#tools]
calendly_get_current_user [#calendly_get_current_user]
Get current user
*No parameters.*
calendly_list_event_types [#calendly_list_event_types]
List event types
calendly_get_event_type [#calendly_get_event_type]
Get event type
calendly_list_scheduled_events [#calendly_list_scheduled_events]
List scheduled events
calendly_get_scheduled_event [#calendly_get_scheduled_event]
Get scheduled event
calendly_list_scheduled_event_invitees [#calendly_list_scheduled_event_invitees]
List scheduled event invitees
calendly_list_availability_schedules [#calendly_list_availability_schedules]
List availability schedules
Notes [#notes]
* Category: Scheduling
* Authentication mode: OAuth
# Canva Integration
The Canva integration provides access to list and create Canva designs, manage folders, and export assets through the Integrate MCP server.
Installation [#installation]
The Canva integration is included with the SDK:
```typescript
import { canvaIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Canva OAuth App [#1-create-a-canva-oauth-app]
1. Create an OAuth application for Canva
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Canva integration to your server configuration. The integration automatically reads `CANVA_CLIENT_ID` and `CANVA_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, canvaIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
canvaIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
canvaIntegration({
clientId: process.env.CUSTOM_CANVA_ID,
clientSecret: process.env.CUSTOM_CANVA_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("canva");
const result = await client.canva.getMe({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, canvaIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [canvaIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
canva_get_me [#canva_get_me]
Get me
*No parameters.*
canva_get_profile [#canva_get_profile]
Get profile
*No parameters.*
canva_list_designs [#canva_list_designs]
List designs
canva_get_design [#canva_get_design]
Get design
canva_get_design_export_formats [#canva_get_design_export_formats]
Get design export formats
canva_create_design [#canva_create_design]
Create design
canva_get_folder [#canva_get_folder]
Get folder
canva_list_folder_items [#canva_list_folder_items]
List folder items
canva_create_folder [#canva_create_folder]
Create folder
canva_update_folder [#canva_update_folder]
Update folder
canva_delete_folder [#canva_delete_folder]
Delete folder
canva_list_brand_templates [#canva_list_brand_templates]
List brand templates
canva_get_brand_template [#canva_get_brand_template]
Get brand template
canva_create_export_job [#canva_create_export_job]
Create export job
canva_get_export_job [#canva_get_export_job]
Get export job
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Canvas LMS Integration
The Canvas LMS integration provides access to manage Canvas LMS list courses, get course, list assignments, create assignment, list submissions through the Integrate MCP server.
Installation [#installation]
The Canvas LMS integration is included with the SDK:
```typescript
import { canvasLmsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Canvas LMS OAuth App [#1-create-a-canvas-lms-oauth-app]
1. Create an OAuth application for Canvas LMS
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Canvas LMS integration to your server configuration. The integration automatically reads `CANVAS_LMS_CLIENT_ID` and `CANVAS_LMS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, canvasLmsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
canvasLmsIntegration({
scopes: ["url:GET|/api/v1/courses", "url:GET|/api/v1/users/:id/profile", "url:POST|/api/v1/courses/:course_id/assignments"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
canvasLmsIntegration({
clientId: process.env.CUSTOM_CANVAS_LMS_ID,
clientSecret: process.env.CUSTOM_CANVAS_LMS_SECRET,
scopes: ["url:GET|/api/v1/courses", "url:GET|/api/v1/users/:id/profile", "url:POST|/api/v1/courses/:course_id/assignments"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("canvas_lms");
const result = await client.canvas_lms.listCourses({
canvas_domain: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, canvasLmsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [canvasLmsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `url:GET|/api/v1/courses`
* `url:GET|/api/v1/users/:id/profile`
* `url:POST|/api/v1/courses/:course_id/assignments`
Tools [#tools]
canvas_lms_list_courses [#canvas_lms_list_courses]
Lms list courses
canvas_lms_get_course [#canvas_lms_get_course]
Lms get course
canvas_lms_list_assignments [#canvas_lms_list_assignments]
Lms list assignments
canvas_lms_create_assignment [#canvas_lms_create_assignment]
Lms create assignment
canvas_lms_list_submissions [#canvas_lms_list_submissions]
Lms list submissions
canvas_lms_list_users [#canvas_lms_list_users]
Lms list users
Notes [#notes]
* Category: Education
* Authentication mode: OAuth
# Clerk Integration
The Clerk integration provides access to manage Clerk users, organizations, sessions, and authentication settings through the Integrate MCP server.
Installation [#installation]
The Clerk integration is included with the SDK:
```typescript
import { clerkIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Clerk to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, clerkIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
clerkIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.clerk.listUsers({});
console.log(result);
```
Environment Variables [#environment-variables]
* `CLERK_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
clerk_list_users [#clerk_list_users]
List users
clerk_get_user [#clerk_get_user]
Get user
clerk_create_user [#clerk_create_user]
Create user
clerk_update_user [#clerk_update_user]
Update user
clerk_delete_user [#clerk_delete_user]
Delete user
clerk_list_organizations [#clerk_list_organizations]
List organizations
clerk_get_organization [#clerk_get_organization]
Get organization
clerk_create_organization [#clerk_create_organization]
Create organization
clerk_update_organization [#clerk_update_organization]
Update organization
clerk_delete_organization [#clerk_delete_organization]
Delete organization
clerk_list_sessions [#clerk_list_sessions]
List sessions
clerk_get_session [#clerk_get_session]
Get session
clerk_revoke_session [#clerk_revoke_session]
Revoke session
Notes [#notes]
* Category: Identity & Access
* Authentication mode: API key
# ClickUp Integration
The ClickUp integration provides access to manage ClickUp tasks, lists, spaces, and workspaces through the Integrate MCP server.
Installation [#installation]
The ClickUp integration is included with the SDK:
```typescript
import { clickupIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a ClickUp OAuth App [#1-create-a-clickup-oauth-app]
1. Go to [App Developer Portal](https://app.clickup.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the ClickUp integration to your server configuration. The integration automatically reads `CLICKUP_CLIENT_ID` and `CLICKUP_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, clickupIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
clickupIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
clickupIntegration({
clientId: process.env.CUSTOM_CLICKUP_ID,
clientSecret: process.env.CUSTOM_CLICKUP_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("clickup");
// Use client.clickup methods after connecting
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, clickupIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [clickupIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
clickup_get_authorized_user [#clickup_get_authorized_user]
Get authorized user
*No parameters.*
clickup_list_teams [#clickup_list_teams]
List teams
*No parameters.*
clickup_list_spaces [#clickup_list_spaces]
List spaces
*No parameters.*
clickup_list_folders [#clickup_list_folders]
List folders
*No parameters.*
clickup_list_lists_in_folder [#clickup_list_lists_in_folder]
List lists in folder
*No parameters.*
clickup_list_folderless_lists [#clickup_list_folderless_lists]
List folderless lists
*No parameters.*
clickup_list_tasks [#clickup_list_tasks]
List tasks
*No parameters.*
clickup_get_task [#clickup_get_task]
Get task
*No parameters.*
clickup_create_task [#clickup_create_task]
Create task
*No parameters.*
clickup_update_task [#clickup_update_task]
Update task
*No parameters.*
clickup_delete_task [#clickup_delete_task]
Delete task
*No parameters.*
clickup_list_task_comments [#clickup_list_task_comments]
List task comments
*No parameters.*
clickup_create_task_comment [#clickup_create_task_comment]
Create task comment
*No parameters.*
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Cloudflare Integration
The Cloudflare integration provides access to manage Cloudflare zones, DNS, cache, and Workers via the Cloudflare API through the Integrate MCP server.
Installation [#installation]
The Cloudflare integration is included with the SDK:
```typescript
import { cloudflareIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Cloudflare to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, cloudflareIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
cloudflareIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.cloudflare.verifyToken({});
console.log(result);
```
Environment Variables [#environment-variables]
* `CLOUDFLARE_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `account:read`
* `user:read`
* `zone:read`
* `workers:read`
* `workers:write`
* `pages:write`
* `offline_access`
Tools [#tools]
cloudflare_verify_token [#cloudflare_verify_token]
Verify token
*No parameters.*
cloudflare_get_user [#cloudflare_get_user]
Get user
*No parameters.*
cloudflare_list_accounts [#cloudflare_list_accounts]
List accounts
cloudflare_get_account [#cloudflare_get_account]
Get account
cloudflare_list_zones [#cloudflare_list_zones]
List zones
cloudflare_get_zone [#cloudflare_get_zone]
Get zone
cloudflare_list_dns_records [#cloudflare_list_dns_records]
List dns records
cloudflare_create_dns_record [#cloudflare_create_dns_record]
Create dns record
cloudflare_update_dns_record [#cloudflare_update_dns_record]
Update dns record
cloudflare_delete_dns_record [#cloudflare_delete_dns_record]
Delete dns record
cloudflare_purge_zone_cache [#cloudflare_purge_zone_cache]
Purge zone cache
cloudflare_list_worker_scripts [#cloudflare_list_worker_scripts]
List worker scripts
Notes [#notes]
* Category: Infrastructure
* Authentication mode: API key
# Confluence Cloud Integration
The Confluence Cloud integration provides access to manage Confluence spaces, pages, search, comments, and attachments through the Integrate MCP server.
Installation [#installation]
The Confluence Cloud integration is included with the SDK:
```typescript
import { confluenceIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Confluence Cloud OAuth App [#1-create-a-confluence-cloud-oauth-app]
1. Go to [Auth Developer Portal](https://auth.atlassian.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Confluence Cloud integration to your server configuration. The integration automatically reads `CONFLUENCE_CLIENT_ID` and `CONFLUENCE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, confluenceIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
confluenceIntegration({
scopes: ["read:confluence-content.all", "write:confluence-content", "read:confluence-space.summary", "read:confluence-props", "offline_access"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
confluenceIntegration({
clientId: process.env.CUSTOM_CONFLUENCE_ID,
clientSecret: process.env.CUSTOM_CONFLUENCE_SECRET,
scopes: ["read:confluence-content.all", "write:confluence-content", "read:confluence-space.summary", "read:confluence-props", "offline_access"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("confluence");
const result = await client.confluence.listAccessibleResources({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, confluenceIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [confluenceIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `read:confluence-content.all`
* `write:confluence-content`
* `read:confluence-space.summary`
* `read:confluence-props`
* `offline_access`
Tools [#tools]
confluence_list_accessible_resources [#confluence_list_accessible_resources]
List accessible resources
*No parameters.*
confluence_list_spaces [#confluence_list_spaces]
List spaces
confluence_get_space [#confluence_get_space]
Get space
confluence_list_pages [#confluence_list_pages]
List pages
confluence_get_page [#confluence_get_page]
Get page
confluence_create_page [#confluence_create_page]
Create page
confluence_update_page [#confluence_update_page]
Update page
confluence_delete_page [#confluence_delete_page]
Delete page
confluence_search [#confluence_search]
Search
confluence_list_comments [#confluence_list_comments]
List comments
confluence_create_comment [#confluence_create_comment]
Create comment
confluence_list_attachments [#confluence_list_attachments]
List attachments
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Contentful Integration
The Contentful integration provides access to manage Contentful list spaces, get space, list entries, get entry, create entry through the Integrate MCP server.
Installation [#installation]
The Contentful integration is included with the SDK:
```typescript
import { contentfulIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Contentful OAuth App [#1-create-a-contentful-oauth-app]
1. Create an OAuth application for Contentful
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Contentful integration to your server configuration. The integration automatically reads `CONTENTFUL_CLIENT_ID` and `CONTENTFUL_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, contentfulIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
contentfulIntegration({
scopes: ["content_management_manage"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
contentfulIntegration({
clientId: process.env.CUSTOM_CONTENTFUL_ID,
clientSecret: process.env.CUSTOM_CONTENTFUL_SECRET,
scopes: ["content_management_manage"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("contentful");
const result = await client.contentful.listSpaces({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, contentfulIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [contentfulIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `content_management_manage`
Tools [#tools]
contentful_list_spaces [#contentful_list_spaces]
List spaces
contentful_get_space [#contentful_get_space]
Get space
contentful_list_entries [#contentful_list_entries]
List entries
contentful_get_entry [#contentful_get_entry]
Get entry
contentful_create_entry [#contentful_create_entry]
Create entry
contentful_publish_entry [#contentful_publish_entry]
Publish entry
Notes [#notes]
* Category: Websites & CMS
* Authentication mode: OAuth
# Convex Integration
The Convex integration provides access to manage Convex projects, deployments, regions, classes, and environment variables through the Integrate MCP server.
Installation [#installation]
The Convex integration is included with the SDK:
```typescript
import { convexIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Convex to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, convexIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
convexIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.convex.managementTokenDetails({});
console.log(result);
```
Environment Variables [#environment-variables]
* `CONVEX_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
convex_management_token_details [#convex_management_token_details]
Management token details
*No parameters.*
convex_management_list_projects [#convex_management_list_projects]
Management list projects
convex_management_create_project [#convex_management_create_project]
Management create project
convex_management_get_project [#convex_management_get_project]
Management get project
convex_management_delete_project [#convex_management_delete_project]
Management delete project
convex_management_list_deployments [#convex_management_list_deployments]
Management list deployments
convex_management_list_team_deployments [#convex_management_list_team_deployments]
Management list team deployments
convex_management_get_deployment [#convex_management_get_deployment]
Management get deployment
convex_management_create_deployment [#convex_management_create_deployment]
Management create deployment
convex_management_update_deployment [#convex_management_update_deployment]
Management update deployment
convex_management_delete_deployment [#convex_management_delete_deployment]
Management delete deployment
convex_management_list_deployment_regions [#convex_management_list_deployment_regions]
Management list deployment regions
*No parameters.*
convex_management_list_deployment_classes [#convex_management_list_deployment_classes]
Management list deployment classes
*No parameters.*
convex_management_list_default_environment_variables [#convex_management_list_default_environment_variables]
Management list default environment variables
convex_management_update_default_environment_variables [#convex_management_update_default_environment_variables]
Management update default environment variables
convex_deployment_list_environment_variables [#convex_deployment_list_environment_variables]
Deployment list environment variables
convex_deployment_update_environment_variables [#convex_deployment_update_environment_variables]
Deployment update environment variables
Notes [#notes]
* Category: Engineering
* Authentication mode: API key
# Cursor Integration
The Cursor integration provides access to manage Cursor Cloud Agents and background tasks through the Integrate MCP server.
Installation [#installation]
The Cursor integration is included with the SDK:
```typescript
import { cursorIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Cursor to your server configuration:
```typescript
import { createMCPServer, cursorIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
cursorIntegration(),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.cursor.listAgents({});
console.log(result);
```
Configuration Options [#configuration-options]
Tools [#tools]
cursor_list_agents [#cursor_list_agents]
List all cloud agents
cursor_get_agent [#cursor_get_agent]
Get agent status
cursor_get_conversation [#cursor_get_conversation]
Get conversation history
cursor_launch_agent [#cursor_launch_agent]
Launch a new agent
cursor_followup_agent [#cursor_followup_agent]
Add follow-up instruction
cursor_stop_agent [#cursor_stop_agent]
Stop a running agent
cursor_delete_agent [#cursor_delete_agent]
Delete an agent
cursor_get_me [#cursor_get_me]
Get API key info
*No parameters.*
cursor_list_models [#cursor_list_models]
List available models
cursor_list_repositories [#cursor_list_repositories]
List GitHub repositories
Notes [#notes]
* Category: Engineering
* Authentication mode: None
# Databricks Integration
The Databricks integration provides access to run Databricks jobs, list clusters and SQL warehouses, and inspect workspace paths through the Integrate MCP server.
Installation [#installation]
The Databricks integration is included with the SDK:
```typescript
import { databricksIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Databricks OAuth App [#1-create-a-databricks-oauth-app]
1. Create an OAuth application for Databricks
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Databricks integration to your server configuration. The integration automatically reads `DATABRICKS_CLIENT_ID` and `DATABRICKS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, databricksIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
databricksIntegration({
scopes: ["all-apis", "offline_access"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
databricksIntegration({
clientId: process.env.CUSTOM_DATABRICKS_ID,
clientSecret: process.env.CUSTOM_DATABRICKS_SECRET,
scopes: ["all-apis", "offline_access"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("databricks");
const result = await client.databricks.currentUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, databricksIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [databricksIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `all-apis`
* `offline_access`
Tools [#tools]
databricks_current_user [#databricks_current_user]
Current user
databricks_clusters_list [#databricks_clusters_list]
Clusters list
databricks_clusters_get [#databricks_clusters_get]
Clusters get
databricks_jobs_list [#databricks_jobs_list]
Jobs list
databricks_jobs_get [#databricks_jobs_get]
Jobs get
databricks_jobs_run_now [#databricks_jobs_run_now]
Jobs run now
databricks_sql_warehouses_list [#databricks_sql_warehouses_list]
Sql warehouses list
databricks_workspace_get_status [#databricks_workspace_get_status]
Workspace get status
Notes [#notes]
* Category: Engineering
* Authentication mode: OAuth
# Datadog Integration
The Datadog integration provides access to monitor Datadog metrics, logs, dashboards, and alerts through the Integrate MCP server.
Installation [#installation]
The Datadog integration is included with the SDK:
```typescript
import { datadogIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Datadog to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, datadogIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
datadogIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.datadog.listMonitors({});
console.log(result);
```
Environment Variables [#environment-variables]
* `DATADOG_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `monitors_read`
* `dashboards_read`
* `metrics_read`
* `logs_read_data`
Tools [#tools]
datadog_list_monitors [#datadog_list_monitors]
List monitors
datadog_get_monitor [#datadog_get_monitor]
Get monitor
datadog_list_dashboards [#datadog_list_dashboards]
List dashboards
datadog_get_dashboard [#datadog_get_dashboard]
Get dashboard
datadog_search_logs [#datadog_search_logs]
Search logs
Notes [#notes]
* Category: Engineering
* Authentication mode: API key
# Deezer Integration
The Deezer integration provides access to manage Deezer get user, search, get album, get track, list playlists through the Integrate MCP server.
Installation [#installation]
The Deezer integration is included with the SDK:
```typescript
import { deezerIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Deezer OAuth App [#1-create-a-deezer-oauth-app]
1. Create an OAuth application for Deezer
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Deezer integration to your server configuration. The integration automatically reads `DEEZER_CLIENT_ID` and `DEEZER_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, deezerIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
deezerIntegration({
scopes: ["basic_access", "email", "manage_library", "delete_library", "listening_history", "offline_access"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
deezerIntegration({
clientId: process.env.CUSTOM_DEEZER_ID,
clientSecret: process.env.CUSTOM_DEEZER_SECRET,
scopes: ["basic_access", "email", "manage_library", "delete_library", "listening_history", "offline_access"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("deezer");
const result = await client.deezer.getUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, deezerIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [deezerIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `basic_access`
* `email`
* `manage_library`
* `delete_library`
* `listening_history`
* `offline_access`
Tools [#tools]
deezer_get_user [#deezer_get_user]
Get user
*No parameters.*
deezer_search [#deezer_search]
Search
deezer_get_album [#deezer_get_album]
Get album
deezer_get_track [#deezer_get_track]
Get track
deezer_list_playlists [#deezer_list_playlists]
List playlists
deezer_add_track_to_playlist [#deezer_add_track_to_playlist]
Add track to playlist
Notes [#notes]
* Category: Entertainment
* Authentication mode: OAuth
# Default (server)
The default server integration provides access to server-level tools that don't belong to a specific integration. These tools are always available on both the client and server without any configuration.
Installation [#installation]
The server namespace is automatically included with the SDK - no installation needed. It's always available on all MCP clients:
```typescript
import { client } from "integrate-sdk";
// Server namespace is always available
const tools = await client.server.listToolsByIntegration({
integration: "github",
});
```
Setup [#setup]
No Configuration Required [#no-configuration-required]
Unlike other integrations, the server namespace requires no setup or configuration. It's automatically included in both:
* **MCP Client** - Available via `client.server.*` on all clients
* **MCP Server** - Automatically handles server-level tool calls
Client-Side Usage [#client-side-usage]
The default client automatically includes the server namespace. You can use it directly:
```typescript
import { client } from "integrate-sdk";
const tools = await client.server.listToolsByIntegration({
integration: "github",
});
```
If you're using a custom client, the server namespace is still always available:
```typescript
import { createMCPClient, githubIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [githubIntegration()],
});
// Server namespace is always available, even on custom clients
const tools = await customClient.server.listToolsByIntegration({
integration: "github",
});
```
Server-Side Usage [#server-side-usage]
When using the server client, the server namespace is also available:
```typescript
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [githubIntegration()],
});
// Server namespace works on server clients too
const tools = await serverClient.server.listToolsByIntegration({
integration: "github",
});
```
Available Tools [#available-tools]
Tool Discovery [#tool-discovery]
* **`listAllProviders`** - List all providers available on the MCP server
* **`listToolsByIntegration`** - List all tools available for a specific integration
* **`listConfiguredIntegrations`** - List integrations configured for this application
Examples [#examples]
List All Providers [#list-all-providers]
```typescript
// List all available providers on the MCP server
const result = await client.server.listAllProviders();
console.log("All providers:", result);
```
List Tools for an Integration [#list-tools-for-an-integration]
```typescript
// List all available GitHub tools
const result = await client.server.listToolsByIntegration({
integration: "github",
});
console.log("GitHub tools:", result);
```
Discover Available Integrations [#discover-available-integrations]
You can use this tool to discover what tools are available for any integration:
```typescript
// Check what Gmail tools are available
const gmailTools = await client.server.listToolsByIntegration({
integration: "gmail",
});
// Check what Notion tools are available
const notionTools = await client.server.listToolsByIntegration({
integration: "notion",
});
console.log("Gmail tools:", gmailTools);
console.log("Notion tools:", notionTools);
```
List Configured Integrations [#list-configured-integrations]
Get a list of integrations configured for your application. The behavior depends on how you created your client:
**Default Client** - Fetches from server:
When using the default exported client (`import { client } from 'integrate-sdk'`), this method queries the server to get the list of integrations actually configured with OAuth credentials via `createMCPServer()`:
```typescript
import { client } from "integrate-sdk";
// Fetches from server to get what's actually configured
const { integrations } = await client.server.listConfiguredIntegrations();
console.log(`Server has ${integrations.length} integrations configured:`);
integrations.forEach((integration) => {
console.log(`- ${integration.name} (${integration.id})`);
console.log(` OAuth: ${integration.hasOAuth ? 'Yes' : 'No'}`);
});
```
**Custom Client** - Uses local config:
When using a custom client created via `createMCPClient()`, this method returns the integrations you explicitly configured (no server call):
```typescript
import { createMCPClient, githubIntegration, gmailIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [githubIntegration(), gmailIntegration()],
});
// Returns local config - no server call
const { integrations } = await customClient.server.listConfiguredIntegrations();
// Returns github and gmail (what you configured)
```
**Server Client** - Uses local config:
Server clients always return their local configuration (they ARE the server):
```typescript
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [githubIntegration({ clientId: "...", clientSecret: "..." })],
});
// Returns local config
const { integrations } = await serverClient.server.listConfiguredIntegrations();
```
**With full tool metadata:**
If you need tool descriptions and input schemas, use the `includeToolMetadata` option. This fetches metadata for all integrations using batched requests with concurrency control to avoid rate limiting:
```typescript
// Complete: Get configured integrations with full tool metadata
const { integrations } = await client.server.listConfiguredIntegrations({
includeToolMetadata: true,
});
integrations.forEach((integration) => {
console.log(`${integration.name}:`);
integration.toolMetadata?.forEach((tool) => {
console.log(` - ${tool.name}: ${tool.description}`);
if (tool.inputSchema?.required) {
console.log(` Required fields: ${tool.inputSchema.required.join(', ')}`);
}
});
});
```
**Response format (basic):**
```typescript
{
integrations: [
{
id: "github",
name: "GitHub",
description: "Manage GitHub repos, issues, and pull requests",
category: "Engineering",
tools: ["github_create_issue", "github_list_repos", ...],
hasOAuth: true,
scopes: ["repo", "user"],
provider: "github"
},
{
id: "gmail",
name: "Gmail",
description: "Send, read, and search Gmail messages",
category: "Communication",
tools: ["gmail_send_email", "gmail_list_messages", ...],
hasOAuth: true,
scopes: ["gmail.readonly"],
provider: "gmail"
}
]
}
```
**Response format (with metadata):**
```typescript
{
integrations: [
{
id: "github",
name: "GitHub",
description: "Manage GitHub repos, issues, and pull requests",
category: "Engineering",
tools: ["github_create_issue", "github_list_repos", ...],
hasOAuth: true,
scopes: ["repo", "user"],
provider: "github",
toolMetadata: [
{
name: "github_create_issue",
description: "Create a new issue in a GitHub repository",
inputSchema: {
type: "object",
properties: {
title: { type: "string" },
body: { type: "string" },
labels: { type: "array" }
},
required: ["title"]
}
},
// ... more tools
]
}
]
}
```
Dynamic Tool Discovery [#dynamic-tool-discovery]
Use this tool to dynamically discover available tools at runtime:
```typescript
async function getIntegrationTools(integrationName: string) {
try {
const result = await client.server.listToolsByIntegration({
integration: integrationName,
});
return result;
} catch (error) {
console.error(`Failed to get tools for ${integrationName}:`, error);
return null;
}
}
// Use it to discover tools
const githubTools = await getIntegrationTools("github");
const gmailTools = await getIntegrationTools("gmail");
```
Error Handling [#error-handling]
```typescript
try {
const result = await client.server.listToolsByIntegration({
integration: "github",
});
console.log("Tools:", result);
} catch (error) {
if (error.message.includes("not found")) {
console.error("Integration not found");
} else if (error.message.includes("authentication")) {
console.error("Authentication required");
} else {
console.error("Unexpected error:", error);
}
}
```
Next Steps [#next-steps]
* Explore the [GitHub Integration](/docs/integrations/github)
* Explore the [Gmail Integration](/docs/integrations/gmail)
* Learn about [custom integrations](/docs/integrations#custom-integrations)
* See [Advanced Usage](/docs/getting-started/advanced-usage) for more examples
# DHL Integration
The DHL integration provides access to manage DHL track shipment, create shipment, get label, delete shipment, validate address through the Integrate MCP server.
Installation [#installation]
The DHL integration is included with the SDK:
```typescript
import { dhlIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a DHL OAuth App [#1-create-a-dhl-oauth-app]
1. Create an OAuth application for DHL
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the DHL integration to your server configuration. The integration automatically reads `DHL_CLIENT_ID` and `DHL_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, dhlIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
dhlIntegration({
scopes: ["shipping", "tracking"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
dhlIntegration({
clientId: process.env.CUSTOM_DHL_ID,
clientSecret: process.env.CUSTOM_DHL_SECRET,
scopes: ["shipping", "tracking"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("dhl");
const result = await client.dhl.trackShipment({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, dhlIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [dhlIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `shipping`
* `tracking`
Tools [#tools]
dhl_track_shipment [#dhl_track_shipment]
Track shipment
dhl_create_shipment [#dhl_create_shipment]
Create shipment
dhl_get_label [#dhl_get_label]
Get label
dhl_delete_shipment [#dhl_delete_shipment]
Delete shipment
dhl_validate_address [#dhl_validate_address]
Validate address
Notes [#notes]
* Category: Shipping & Logistics
* Authentication mode: OAuth
# Discord Integration
The Discord integration provides access to send and manage Discord messages; list guilds and channels (bot token required on server for channel APIs) through the Integrate MCP server.
Installation [#installation]
The Discord integration is included with the SDK:
```typescript
import { discordIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Discord OAuth App [#1-create-a-discord-oauth-app]
1. Go to [Discord Developer Portal](https://discord.com/developers/applications)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Discord integration to your server configuration. The integration automatically reads `DISCORD_CLIENT_ID` and `DISCORD_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, discordIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
discordIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
discordIntegration({
clientId: process.env.CUSTOM_DISCORD_ID,
clientSecret: process.env.CUSTOM_DISCORD_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("discord");
const result = await client.discord.getCurrentUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, discordIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [discordIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
discord_get_current_user [#discord_get_current_user]
Get current user
*No parameters.*
discord_list_my_guilds [#discord_list_my_guilds]
List my guilds
discord_get_guild [#discord_get_guild]
Get guild
discord_list_guild_channels [#discord_list_guild_channels]
List guild channels
discord_get_channel [#discord_get_channel]
Get channel
discord_send_message [#discord_send_message]
Send message
discord_list_messages [#discord_list_messages]
List messages
discord_edit_message [#discord_edit_message]
Edit message
discord_delete_message [#discord_delete_message]
Delete message
Notes [#notes]
* Category: Communication
* Authentication mode: OAuth
# DocuSign Integration
The DocuSign integration provides access to manage DocuSign eSignature accounts, envelopes, recipients, documents, and templates through the Integrate MCP server.
Installation [#installation]
The DocuSign integration is included with the SDK:
```typescript
import { docusignIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a DocuSign OAuth App [#1-create-a-docusign-oauth-app]
1. Create an OAuth application for DocuSign
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the DocuSign integration to your server configuration. The integration automatically reads `DOCUSIGN_CLIENT_ID` and `DOCUSIGN_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, docusignIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
docusignIntegration({
scopes: ["signature", "impersonation"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
docusignIntegration({
clientId: process.env.CUSTOM_DOCUSIGN_ID,
clientSecret: process.env.CUSTOM_DOCUSIGN_SECRET,
scopes: ["signature", "impersonation"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("docusign");
const result = await client.docusign.getUserInfo({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, docusignIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [docusignIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `signature`
* `impersonation`
Tools [#tools]
docusign_get_user_info [#docusign_get_user_info]
Get user info
*No parameters.*
docusign_list_envelopes [#docusign_list_envelopes]
List envelopes
docusign_get_envelope [#docusign_get_envelope]
Get envelope
docusign_create_envelope [#docusign_create_envelope]
Create envelope
docusign_list_recipients [#docusign_list_recipients]
List recipients
docusign_get_document [#docusign_get_document]
Get document
docusign_list_templates [#docusign_list_templates]
List templates
Notes [#notes]
* Category: Legal
* Authentication mode: OAuth
# Dropbox Integration
The Dropbox integration provides access to manage Dropbox files, folders, and sharing through the Integrate MCP server.
Installation [#installation]
The Dropbox integration is included with the SDK:
```typescript
import { dropboxIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Dropbox OAuth App [#1-create-a-dropbox-oauth-app]
1. Create an OAuth application for Dropbox
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Dropbox integration to your server configuration. The integration automatically reads `DROPBOX_CLIENT_ID` and `DROPBOX_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, dropboxIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
dropboxIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
dropboxIntegration({
clientId: process.env.CUSTOM_DROPBOX_ID,
clientSecret: process.env.CUSTOM_DROPBOX_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("dropbox");
// Use client.dropbox methods after connecting
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, dropboxIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [dropboxIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
dropbox_get_current_account [#dropbox_get_current_account]
Get current account
*No parameters.*
dropbox_get_space_usage [#dropbox_get_space_usage]
Get space usage
*No parameters.*
dropbox_list_folder [#dropbox_list_folder]
List folder
*No parameters.*
dropbox_list_folder_continue [#dropbox_list_folder_continue]
List folder continue
*No parameters.*
dropbox_get_metadata [#dropbox_get_metadata]
Get metadata
*No parameters.*
dropbox_search_files [#dropbox_search_files]
Search files
*No parameters.*
dropbox_create_folder [#dropbox_create_folder]
Create folder
*No parameters.*
dropbox_delete_path [#dropbox_delete_path]
Delete path
*No parameters.*
dropbox_move_path [#dropbox_move_path]
Move path
*No parameters.*
dropbox_copy_path [#dropbox_copy_path]
Copy path
*No parameters.*
dropbox_upload_text_file [#dropbox_upload_text_file]
Upload text file
*No parameters.*
dropbox_download_file [#dropbox_download_file]
Download file
*No parameters.*
dropbox_get_temporary_link [#dropbox_get_temporary_link]
Get temporary link
*No parameters.*
dropbox_create_shared_link [#dropbox_create_shared_link]
Create shared link
*No parameters.*
dropbox_list_shared_links [#dropbox_list_shared_links]
List shared links
*No parameters.*
dropbox_revoke_shared_link [#dropbox_revoke_shared_link]
Revoke shared link
*No parameters.*
Notes [#notes]
* Category: Storage
* Authentication mode: OAuth
# Dropbox Sign Integration
The Dropbox Sign integration provides access to manage Dropbox Sign get account, list signature requests, get signature request, send signature request, list templates through the Integrate MCP server.
Installation [#installation]
The Dropbox Sign integration is included with the SDK:
```typescript
import { dropboxSignIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Dropbox Sign OAuth App [#1-create-a-dropbox-sign-oauth-app]
1. Create an OAuth application for Dropbox Sign
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Dropbox Sign integration to your server configuration. The integration automatically reads `DROPBOX_SIGN_CLIENT_ID` and `DROPBOX_SIGN_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, dropboxSignIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
dropboxSignIntegration({
scopes: ["basic_account_info", "request_signature", "signature_request_access"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
dropboxSignIntegration({
clientId: process.env.CUSTOM_DROPBOX_SIGN_ID,
clientSecret: process.env.CUSTOM_DROPBOX_SIGN_SECRET,
scopes: ["basic_account_info", "request_signature", "signature_request_access"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("dropbox_sign");
const result = await client.dropbox_sign.getAccount({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, dropboxSignIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [dropboxSignIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `basic_account_info`
* `request_signature`
* `signature_request_access`
Tools [#tools]
dropbox_sign_get_account [#dropbox_sign_get_account]
Sign get account
*No parameters.*
dropbox_sign_list_signature_requests [#dropbox_sign_list_signature_requests]
Sign list signature requests
dropbox_sign_get_signature_request [#dropbox_sign_get_signature_request]
Sign get signature request
dropbox_sign_send_signature_request [#dropbox_sign_send_signature_request]
Sign send signature request
dropbox_sign_list_templates [#dropbox_sign_list_templates]
Sign list templates
dropbox_sign_get_template [#dropbox_sign_get_template]
Sign get template
Notes [#notes]
* Category: Legal
* Authentication mode: OAuth
# eBay Integration
The eBay integration provides access to manage eBay browse, inventory, offers, orders, and fulfillment APIs through the Integrate MCP server.
Installation [#installation]
The eBay integration is included with the SDK:
```typescript
import { ebayIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an eBay OAuth App [#1-create-an-ebay-oauth-app]
1. Create an OAuth application for eBay
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the eBay integration to your server configuration. The integration automatically reads `EBAY_CLIENT_ID` and `EBAY_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, ebayIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
ebayIntegration({
scopes: ["https://api.ebay.com/oauth/api_scope", "https://api.ebay.com/oauth/api_scope/sell.inventory", "https://api.ebay.com/oauth/api_scope/sell.fulfillment", "https://api.ebay.com/oauth/api_scope/sell.account"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
ebayIntegration({
clientId: process.env.CUSTOM_EBAY_ID,
clientSecret: process.env.CUSTOM_EBAY_SECRET,
scopes: ["https://api.ebay.com/oauth/api_scope", "https://api.ebay.com/oauth/api_scope/sell.inventory", "https://api.ebay.com/oauth/api_scope/sell.fulfillment", "https://api.ebay.com/oauth/api_scope/sell.account"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("ebay");
const result = await client.ebay.searchItems({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, ebayIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [ebayIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `https://api.ebay.com/oauth/api_scope`
* `https://api.ebay.com/oauth/api_scope/sell.inventory`
* `https://api.ebay.com/oauth/api_scope/sell.fulfillment`
* `https://api.ebay.com/oauth/api_scope/sell.account`
Tools [#tools]
ebay_search_items [#ebay_search_items]
Search items
ebay_get_item [#ebay_get_item]
Get item
ebay_get_privileges [#ebay_get_privileges]
Get privileges
*No parameters.*
ebay_list_inventory_items [#ebay_list_inventory_items]
List inventory items
ebay_create_or_replace_inventory_item [#ebay_create_or_replace_inventory_item]
Create or replace inventory item
ebay_list_offers [#ebay_list_offers]
List offers
ebay_create_offer [#ebay_create_offer]
Create offer
ebay_list_orders [#ebay_list_orders]
List orders
ebay_get_order [#ebay_get_order]
Get order
Notes [#notes]
* Category: Commerce
* Authentication mode: OAuth
# eToro Integration
The eToro integration provides access to access eToro Public API identity, portfolio, market data, trade history, and watchlists through the Integrate MCP server.
Installation [#installation]
The eToro integration is included with the SDK:
```typescript
import { etoroIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add eToro to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, etoroIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
etoroIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.etoro.getIdentity({});
console.log(result);
```
Environment Variables [#environment-variables]
* `ETORO_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
etoro_get_identity [#etoro_get_identity]
Get identity
*No parameters.*
etoro_get_portfolio [#etoro_get_portfolio]
Get portfolio
*No parameters.*
etoro_search_instruments [#etoro_search_instruments]
Search instruments
etoro_get_instrument_rates [#etoro_get_instrument_rates]
Get instrument rates
etoro_list_trade_history [#etoro_list_trade_history]
List trade history
etoro_list_watchlists [#etoro_list_watchlists]
List watchlists
Notes [#notes]
* Category: Finance
* Authentication mode: API key
# Etsy Integration
The Etsy integration provides access to manage Etsy get me, get shop, list shop listings, create listing, list receipts through the Integrate MCP server.
Installation [#installation]
The Etsy integration is included with the SDK:
```typescript
import { etsyIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Etsy OAuth App [#1-create-an-etsy-oauth-app]
1. Create an OAuth application for Etsy
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Etsy integration to your server configuration. The integration automatically reads `ETSY_CLIENT_ID` and `ETSY_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, etsyIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
etsyIntegration({
scopes: ["listings_r", "listings_w", "transactions_r", "transactions_w", "shops_r", "shops_w", "profile_r"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
etsyIntegration({
clientId: process.env.CUSTOM_ETSY_ID,
clientSecret: process.env.CUSTOM_ETSY_SECRET,
scopes: ["listings_r", "listings_w", "transactions_r", "transactions_w", "shops_r", "shops_w", "profile_r"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("etsy");
const result = await client.etsy.getMe({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, etsyIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [etsyIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `listings_r`
* `listings_w`
* `transactions_r`
* `transactions_w`
* `shops_r`
* `shops_w`
* `profile_r`
Tools [#tools]
etsy_get_me [#etsy_get_me]
Get me
*No parameters.*
etsy_get_shop [#etsy_get_shop]
Get shop
etsy_list_shop_listings [#etsy_list_shop_listings]
List shop listings
etsy_create_listing [#etsy_create_listing]
Create listing
etsy_list_receipts [#etsy_list_receipts]
List receipts
etsy_update_inventory [#etsy_update_inventory]
Update inventory
Notes [#notes]
* Category: Commerce
* Authentication mode: OAuth
# Eventbrite Integration
The Eventbrite integration provides access to manage Eventbrite get user, list organizations, list events, get event, create event through the Integrate MCP server.
Installation [#installation]
The Eventbrite integration is included with the SDK:
```typescript
import { eventbriteIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Eventbrite OAuth App [#1-create-an-eventbrite-oauth-app]
1. Create an OAuth application for Eventbrite
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Eventbrite integration to your server configuration. The integration automatically reads `EVENTBRITE_CLIENT_ID` and `EVENTBRITE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, eventbriteIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
eventbriteIntegration({
scopes: ["eventbrite"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
eventbriteIntegration({
clientId: process.env.CUSTOM_EVENTBRITE_ID,
clientSecret: process.env.CUSTOM_EVENTBRITE_SECRET,
scopes: ["eventbrite"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("eventbrite");
const result = await client.eventbrite.getUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, eventbriteIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [eventbriteIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `eventbrite`
Tools [#tools]
eventbrite_get_user [#eventbrite_get_user]
Get user
*No parameters.*
eventbrite_list_organizations [#eventbrite_list_organizations]
List organizations
*No parameters.*
eventbrite_list_events [#eventbrite_list_events]
List events
eventbrite_get_event [#eventbrite_get_event]
Get event
eventbrite_create_event [#eventbrite_create_event]
Create event
eventbrite_list_attendees [#eventbrite_list_attendees]
List attendees
Notes [#notes]
* Category: Events & Ticketing
* Authentication mode: OAuth
# Exact Online Integration
The Exact Online integration provides access to manage Exact Online list divisions, list accounts, list items, list sales invoices, create sales invoice through the Integrate MCP server.
Installation [#installation]
The Exact Online integration is included with the SDK:
```typescript
import { exactOnlineIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Exact Online OAuth App [#1-create-an-exact-online-oauth-app]
1. Create an OAuth application for Exact Online
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Exact Online integration to your server configuration. The integration automatically reads `EXACT_ONLINE_CLIENT_ID` and `EXACT_ONLINE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, exactOnlineIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
exactOnlineIntegration({
scopes: ["financial", "crm", "sales", "purchase", "offline_access"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
exactOnlineIntegration({
clientId: process.env.CUSTOM_EXACT_ONLINE_ID,
clientSecret: process.env.CUSTOM_EXACT_ONLINE_SECRET,
scopes: ["financial", "crm", "sales", "purchase", "offline_access"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("exact_online");
const result = await client.exact_online.listDivisions({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, exactOnlineIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [exactOnlineIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `financial`
* `crm`
* `sales`
* `purchase`
* `offline_access`
Tools [#tools]
exact_online_list_divisions [#exact_online_list_divisions]
Online list divisions
*No parameters.*
exact_online_list_accounts [#exact_online_list_accounts]
Online list accounts
exact_online_list_items [#exact_online_list_items]
Online list items
exact_online_list_sales_invoices [#exact_online_list_sales_invoices]
Online list sales invoices
exact_online_create_sales_invoice [#exact_online_create_sales_invoice]
Online create sales invoice
exact_online_list_gl_accounts [#exact_online_list_gl_accounts]
Online list gl accounts
Notes [#notes]
* Category: Accounting
* Authentication mode: OAuth
# Excel Integration
The Excel integration provides access to manage Excel workbooks, worksheets, and tables through the Integrate MCP server.
Installation [#installation]
The Excel integration is included with the SDK:
```typescript
import { excelIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Excel OAuth App [#1-create-an-excel-oauth-app]
1. Go to [Azure Portal β App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Excel integration to your server configuration. The integration automatically reads `EXCEL_CLIENT_ID` and `EXCEL_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, excelIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
excelIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
excelIntegration({
clientId: process.env.CUSTOM_EXCEL_ID,
clientSecret: process.env.CUSTOM_EXCEL_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("excel");
const result = await client.excel.list({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, excelIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [excelIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
excel_add_table_rows [#excel_add_table_rows]
Append rows to a table
excel_add_worksheet [#excel_add_worksheet]
Add a new worksheet to a workbook
excel_clear_range [#excel_clear_range]
Clear contents and/or formatting from a cell range
excel_create [#excel_create]
Create a new empty .xlsx workbook in OneDrive
excel_create_table [#excel_create_table]
Create a table from a cell range
excel_delete [#excel_delete]
Delete an Excel workbook permanently
excel_delete_worksheet [#excel_delete_worksheet]
Delete a worksheet from a workbook
excel_get [#excel_get]
Get metadata for an Excel workbook
excel_get_range [#excel_get_range]
Get values, formulas, and formatting from a cell range
excel_get_table_rows [#excel_get_table_rows]
Get rows from a table
excel_get_used_range [#excel_get_used_range]
Get the bounding range of all data in a worksheet
excel_list [#excel_list]
Search for Excel workbooks
excel_list_tables [#excel_list_tables]
List all tables in a worksheet
excel_list_worksheets [#excel_list_worksheets]
List all worksheets in a workbook
excel_share [#excel_share]
Create a sharing link for an Excel workbook
excel_update_range [#excel_update_range]
Update cell values in a range
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Expedia Rapid Integration
The Expedia Rapid integration provides access to manage Expedia Rapid search properties, get property content, get rate quote, create booking, get itinerary through the Integrate MCP server.
Installation [#installation]
The Expedia Rapid integration is included with the SDK:
```typescript
import { expediaIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Expedia Rapid OAuth App [#1-create-an-expedia-rapid-oauth-app]
1. Create an OAuth application for Expedia Rapid
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Expedia Rapid integration to your server configuration. The integration automatically reads `EXPEDIA_CLIENT_ID` and `EXPEDIA_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, expediaIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
expediaIntegration({
scopes: ["rapid"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
expediaIntegration({
clientId: process.env.CUSTOM_EXPEDIA_ID,
clientSecret: process.env.CUSTOM_EXPEDIA_SECRET,
scopes: ["rapid"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("expedia");
const result = await client.expedia.searchProperties({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, expediaIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [expediaIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `rapid`
Tools [#tools]
expedia_search_properties [#expedia_search_properties]
Search properties
expedia_get_property_content [#expedia_get_property_content]
Get property content
expedia_get_rate_quote [#expedia_get_rate_quote]
Get rate quote
expedia_create_booking [#expedia_create_booking]
Create booking
expedia_get_itinerary [#expedia_get_itinerary]
Get itinerary
Notes [#notes]
* Category: Travel
* Authentication mode: OAuth
# Facebook Integration
The Facebook integration provides access to manage Facebook Page posts, comments, reactions, and insights via the Graph API through the Integrate MCP server.
Installation [#installation]
The Facebook integration is included with the SDK:
```typescript
import { facebookIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Facebook OAuth App [#1-create-a-facebook-oauth-app]
1. Go to [Facebook Developer Portal](https://www.facebook.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Facebook integration to your server configuration. The integration automatically reads `FACEBOOK_CLIENT_ID` and `FACEBOOK_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, facebookIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
facebookIntegration({
scopes: ["public_profile", "email", "pages_show_list", "pages_read_engagement", "pages_manage_posts", "pages_read_user_content", "pages_manage_engagement"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
facebookIntegration({
clientId: process.env.CUSTOM_FACEBOOK_ID,
clientSecret: process.env.CUSTOM_FACEBOOK_SECRET,
scopes: ["public_profile", "email", "pages_show_list", "pages_read_engagement", "pages_manage_posts", "pages_read_user_content", "pages_manage_engagement"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("facebook");
const result = await client.facebook.getMe({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, facebookIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [facebookIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `public_profile`
* `email`
* `pages_show_list`
* `pages_read_engagement`
* `pages_manage_posts`
* `pages_read_user_content`
* `pages_manage_engagement`
Tools [#tools]
facebook_get_me [#facebook_get_me]
Get me
facebook_list_pages [#facebook_list_pages]
List pages
facebook_list_page_posts [#facebook_list_page_posts]
List page posts
facebook_get_object [#facebook_get_object]
Get object
facebook_create_page_post [#facebook_create_page_post]
Create page post
facebook_delete_object [#facebook_delete_object]
Delete object
facebook_list_comments [#facebook_list_comments]
List comments
facebook_publish_comment [#facebook_publish_comment]
Publish comment
facebook_get_insights [#facebook_get_insights]
Get insights
facebook_set_comment_visibility [#facebook_set_comment_visibility]
Set comment visibility
facebook_like_object [#facebook_like_object]
Like object
Notes [#notes]
* Category: Social Media
* Authentication mode: OAuth
# FedEx Integration
The FedEx integration provides access to manage FedEx track shipments, rate shipment, create shipment, cancel shipment, validate address through the Integrate MCP server.
Installation [#installation]
The FedEx integration is included with the SDK:
```typescript
import { fedexIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a FedEx OAuth App [#1-create-a-fedex-oauth-app]
1. Create an OAuth application for FedEx
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the FedEx integration to your server configuration. The integration automatically reads `FEDEX_CLIENT_ID` and `FEDEX_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, fedexIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
fedexIntegration({
scopes: ["ship", "track", "rates", "address"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
fedexIntegration({
clientId: process.env.CUSTOM_FEDEX_ID,
clientSecret: process.env.CUSTOM_FEDEX_SECRET,
scopes: ["ship", "track", "rates", "address"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("fedex");
const result = await client.fedex.trackShipments({
tracking_json: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, fedexIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [fedexIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `ship`
* `track`
* `rates`
* `address`
Tools [#tools]
fedex_track_shipments [#fedex_track_shipments]
Track shipments
fedex_rate_shipment [#fedex_rate_shipment]
Rate shipment
fedex_create_shipment [#fedex_create_shipment]
Create shipment
fedex_cancel_shipment [#fedex_cancel_shipment]
Cancel shipment
fedex_validate_address [#fedex_validate_address]
Validate address
Notes [#notes]
* Category: Shipping & Logistics
* Authentication mode: OAuth
# Figma Integration
The Figma integration provides access to access Figma files, comments, and components through the Integrate MCP server.
Installation [#installation]
The Figma integration is included with the SDK:
```typescript
import { figmaIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Figma OAuth App [#1-create-a-figma-oauth-app]
1. Go to [Figma for Developers](https://www.figma.com/developers/apps)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Figma integration to your server configuration. The integration automatically reads `FIGMA_CLIENT_ID` and `FIGMA_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, figmaIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
figmaIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
figmaIntegration({
clientId: process.env.CUSTOM_FIGMA_ID,
clientSecret: process.env.CUSTOM_FIGMA_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("figma");
const result = await client.figma.getFile({
file_key: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, figmaIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [figmaIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
figma_get_file [#figma_get_file]
Get a Figma file by key
figma_get_file_nodes [#figma_get_file_nodes]
Get specific nodes from a file
figma_get_file_meta [#figma_get_file_meta]
Get file metadata (name, last modified, version, etc.) without the full document tree
figma_get_image_fills [#figma_get_image_fills]
Get URLs of image fills used in a file
figma_get_images [#figma_get_images]
Export rendered images for nodes in a file
figma_get_file_versions [#figma_get_file_versions]
Get version history of a file
figma_get_oembed [#figma_get_oembed]
Get oEmbed data for a Figma file (embed metadata for external sites)
figma_get_me [#figma_get_me]
Get the current authenticated user
*No parameters.*
figma_get_comments [#figma_get_comments]
Get comments on a file
figma_post_comment [#figma_post_comment]
Post a comment on a file
figma_delete_comment [#figma_delete_comment]
Delete a comment from a file
figma_get_comment_reactions [#figma_get_comment_reactions]
Get reactions on a comment
figma_post_comment_reaction [#figma_post_comment_reaction]
Add a reaction to a comment
figma_delete_comment_reaction [#figma_delete_comment_reaction]
Delete a reaction from a comment
figma_list_projects [#figma_list_projects]
List projects in a team
figma_get_project_files [#figma_get_project_files]
Get files in a project
figma_get_team_components [#figma_get_team_components]
Get published components for a team
figma_get_file_components [#figma_get_file_components]
Get components defined in a file
figma_get_component [#figma_get_component]
Get a single published component by key
figma_get_team_component_sets [#figma_get_team_component_sets]
Get published component sets for a team
figma_get_file_component_sets [#figma_get_file_component_sets]
Get component sets defined in a file
figma_get_component_set [#figma_get_component_set]
Get a single published component set by key
figma_get_team_styles [#figma_get_team_styles]
Get published styles for a team
figma_get_file_styles [#figma_get_file_styles]
Get styles defined in a file
figma_get_style [#figma_get_style]
Get a single published style by key
figma_list_webhooks [#figma_list_webhooks]
List all webhooks for the authenticated user
figma_create_webhook [#figma_create_webhook]
Create a webhook
figma_get_webhook [#figma_get_webhook]
Get a webhook by ID
figma_update_webhook [#figma_update_webhook]
Update an existing webhook
figma_delete_webhook [#figma_delete_webhook]
Delete a webhook
figma_get_team_webhooks [#figma_get_team_webhooks]
Get all webhooks for a team
figma_get_webhook_requests [#figma_get_webhook_requests]
Get recent delivery requests for a webhook
figma_get_local_variables [#figma_get_local_variables]
Get local variables defined in a file
figma_get_published_variables [#figma_get_published_variables]
Get published variables available to a file
figma_post_variables [#figma_post_variables]
Create, update, or delete variables and variable collections in a file
figma_get_dev_resources [#figma_get_dev_resources]
Get dev resources linked to nodes in a file
figma_post_dev_resources [#figma_post_dev_resources]
Create dev resources linked to file nodes
figma_put_dev_resources [#figma_put_dev_resources]
Update existing dev resources
figma_delete_dev_resource [#figma_delete_dev_resource]
Delete a dev resource from a file
figma_get_payments [#figma_get_payments]
Get payment status for a plugin, widget, or community file.
figma_get_library_analytics_component_actions [#figma_get_library_analytics_component_actions]
Get analytics on component insert/detach actions from a library file
figma_get_library_analytics_component_usages [#figma_get_library_analytics_component_usages]
Get analytics on component usages (instances) from a library file
figma_get_library_analytics_style_actions [#figma_get_library_analytics_style_actions]
Get analytics on style insert/detach actions from a library file
figma_get_library_analytics_style_usages [#figma_get_library_analytics_style_usages]
Get analytics on style usages from a library file
Notes [#notes]
* Category: Engineering
* Authentication mode: OAuth
# Firebase Integration
The Firebase integration provides access to manage Firebase projects and registered apps across web, Android, and Apple platforms through the Integrate MCP server.
Installation [#installation]
The Firebase integration is included with the SDK:
```typescript
import { firebaseIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Firebase OAuth App [#1-create-a-firebase-oauth-app]
1. Create an OAuth application for Firebase
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Firebase integration to your server configuration. The integration automatically reads `FIREBASE_CLIENT_ID` and `FIREBASE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, firebaseIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
firebaseIntegration({
scopes: ["openid", "email", "https://www.googleapis.com/auth/firebase", "https://www.googleapis.com/auth/cloud-platform"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
firebaseIntegration({
clientId: process.env.CUSTOM_FIREBASE_ID,
clientSecret: process.env.CUSTOM_FIREBASE_SECRET,
scopes: ["openid", "email", "https://www.googleapis.com/auth/firebase", "https://www.googleapis.com/auth/cloud-platform"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("firebase");
const result = await client.firebase.listProjects({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, firebaseIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [firebaseIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `openid`
* `email`
* `https://www.googleapis.com/auth/firebase`
* `https://www.googleapis.com/auth/cloud-platform`
Tools [#tools]
firebase_list_projects [#firebase_list_projects]
List projects
firebase_get_project [#firebase_get_project]
Get project
firebase_list_web_apps [#firebase_list_web_apps]
List web apps
firebase_list_android_apps [#firebase_list_android_apps]
List android apps
firebase_list_ios_apps [#firebase_list_ios_apps]
List ios apps
firebase_create_web_app [#firebase_create_web_app]
Create web app
Notes [#notes]
* Category: Infrastructure
* Authentication mode: OAuth
# Fitbit Integration
The Fitbit integration provides access to manage Fitbit get profile, list activities, list sleep, list heart rate, list weight through the Integrate MCP server.
Installation [#installation]
The Fitbit integration is included with the SDK:
```typescript
import { fitbitIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Fitbit OAuth App [#1-create-a-fitbit-oauth-app]
1. Create an OAuth application for Fitbit
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Fitbit integration to your server configuration. The integration automatically reads `FITBIT_CLIENT_ID` and `FITBIT_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, fitbitIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
fitbitIntegration({
scopes: ["activity", "heartrate", "location", "nutrition", "profile", "settings", "sleep", "social", "weight"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
fitbitIntegration({
clientId: process.env.CUSTOM_FITBIT_ID,
clientSecret: process.env.CUSTOM_FITBIT_SECRET,
scopes: ["activity", "heartrate", "location", "nutrition", "profile", "settings", "sleep", "social", "weight"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("fitbit");
const result = await client.fitbit.getProfile({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, fitbitIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [fitbitIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `activity`
* `heartrate`
* `location`
* `nutrition`
* `profile`
* `settings`
* `sleep`
* `social`
* `weight`
Tools [#tools]
fitbit_get_profile [#fitbit_get_profile]
Get profile
*No parameters.*
fitbit_list_activities [#fitbit_list_activities]
List activities
fitbit_list_sleep [#fitbit_list_sleep]
List sleep
fitbit_list_heart_rate [#fitbit_list_heart_rate]
List heart rate
fitbit_list_weight [#fitbit_list_weight]
List weight
fitbit_log_activity [#fitbit_log_activity]
Log activity
Notes [#notes]
* Category: Fitness
* Authentication mode: OAuth
# Foursquare Integration
The Foursquare integration provides access to manage Foursquare search places, get place, get place tips, get place photos, autocomplete places through the Integrate MCP server.
Installation [#installation]
The Foursquare integration is included with the SDK:
```typescript
import { foursquareIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Foursquare OAuth App [#1-create-a-foursquare-oauth-app]
1. Create an OAuth application for Foursquare
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Foursquare integration to your server configuration. The integration automatically reads `FOURSQUARE_CLIENT_ID` and `FOURSQUARE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, foursquareIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
foursquareIntegration({
scopes: ["places", "tips", "photos"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
foursquareIntegration({
clientId: process.env.CUSTOM_FOURSQUARE_ID,
clientSecret: process.env.CUSTOM_FOURSQUARE_SECRET,
scopes: ["places", "tips", "photos"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("foursquare");
const result = await client.foursquare.searchPlaces({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, foursquareIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [foursquareIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `places`
* `tips`
* `photos`
Tools [#tools]
foursquare_search_places [#foursquare_search_places]
Search places
foursquare_get_place [#foursquare_get_place]
Get place
foursquare_get_place_tips [#foursquare_get_place_tips]
Get place tips
foursquare_get_place_photos [#foursquare_get_place_photos]
Get place photos
foursquare_autocomplete_places [#foursquare_autocomplete_places]
Autocomplete places
Notes [#notes]
* Category: Food
* Authentication mode: OAuth
# FreeAgent Integration
The FreeAgent integration provides access to manage FreeAgent get company, list contacts, create contact, list invoices, create invoice through the Integrate MCP server.
Installation [#installation]
The FreeAgent integration is included with the SDK:
```typescript
import { freeagentIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a FreeAgent OAuth App [#1-create-a-freeagent-oauth-app]
1. Create an OAuth application for FreeAgent
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the FreeAgent integration to your server configuration. The integration automatically reads `FREEAGENT_CLIENT_ID` and `FREEAGENT_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, freeagentIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
freeagentIntegration({
scopes: ["full_access"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
freeagentIntegration({
clientId: process.env.CUSTOM_FREEAGENT_ID,
clientSecret: process.env.CUSTOM_FREEAGENT_SECRET,
scopes: ["full_access"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("freeagent");
const result = await client.freeagent.getCompany({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, freeagentIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [freeagentIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `full_access`
Tools [#tools]
freeagent_get_company [#freeagent_get_company]
Get company
*No parameters.*
freeagent_list_contacts [#freeagent_list_contacts]
List contacts
freeagent_create_contact [#freeagent_create_contact]
Create contact
freeagent_list_invoices [#freeagent_list_invoices]
List invoices
freeagent_create_invoice [#freeagent_create_invoice]
Create invoice
freeagent_list_bills [#freeagent_list_bills]
List bills
Notes [#notes]
* Category: Accounting
* Authentication mode: OAuth
# Freshservice Integration
The Freshservice integration provides access to manage Freshservice tickets, requesters, agents, assets, changes, problems, releases, and solutions through the Integrate MCP server.
Installation [#installation]
The Freshservice integration is included with the SDK:
```typescript
import { freshserviceIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Freshservice OAuth App [#1-create-a-freshservice-oauth-app]
1. Create an OAuth application for Freshservice
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Freshservice integration to your server configuration. The integration automatically reads `FRESHSERVICE_CLIENT_ID` and `FRESHSERVICE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, freshserviceIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
freshserviceIntegration({
scopes: ["freshservice.tickets.read", "freshservice.tickets.write", "freshservice.assets.read", "freshservice.solutions.read"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
freshserviceIntegration({
clientId: process.env.CUSTOM_FRESHSERVICE_ID,
clientSecret: process.env.CUSTOM_FRESHSERVICE_SECRET,
scopes: ["freshservice.tickets.read", "freshservice.tickets.write", "freshservice.assets.read", "freshservice.solutions.read"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("freshservice");
const result = await client.freshservice.listTickets({
domain: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, freshserviceIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [freshserviceIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `freshservice.tickets.read`
* `freshservice.tickets.write`
* `freshservice.assets.read`
* `freshservice.solutions.read`
Tools [#tools]
freshservice_list_tickets [#freshservice_list_tickets]
List tickets
freshservice_list_requesters [#freshservice_list_requesters]
List requesters
freshservice_list_agents [#freshservice_list_agents]
List agents
freshservice_list_assets [#freshservice_list_assets]
List assets
freshservice_list_changes [#freshservice_list_changes]
List changes
freshservice_list_problems [#freshservice_list_problems]
List problems
freshservice_list_releases [#freshservice_list_releases]
List releases
freshservice_create_ticket [#freshservice_create_ticket]
Create ticket
freshservice_list_solutions [#freshservice_list_solutions]
List solutions
Notes [#notes]
* Category: Business
* Authentication mode: OAuth
# Garmin Integration
The Garmin integration provides access to manage Garmin list activities, list daily summaries, list sleep, list heart rates, list body composition through the Integrate MCP server.
Installation [#installation]
The Garmin integration is included with the SDK:
```typescript
import { garminIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Garmin OAuth App [#1-create-a-garmin-oauth-app]
1. Create an OAuth application for Garmin
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Garmin integration to your server configuration. The integration automatically reads `GARMIN_CLIENT_ID` and `GARMIN_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, garminIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
garminIntegration({
scopes: ["activities", "heartrate", "sleep", "stress", "body_composition", "user_metrics"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
garminIntegration({
clientId: process.env.CUSTOM_GARMIN_ID,
clientSecret: process.env.CUSTOM_GARMIN_SECRET,
scopes: ["activities", "heartrate", "sleep", "stress", "body_composition", "user_metrics"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("garmin");
const result = await client.garmin.listActivities({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, garminIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [garminIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `activities`
* `heartrate`
* `sleep`
* `stress`
* `body_composition`
* `user_metrics`
Tools [#tools]
garmin_list_activities [#garmin_list_activities]
List activities
garmin_list_daily_summaries [#garmin_list_daily_summaries]
List daily summaries
garmin_list_sleep [#garmin_list_sleep]
List sleep
garmin_list_heart_rates [#garmin_list_heart_rates]
List heart rates
garmin_list_body_composition [#garmin_list_body_composition]
List body composition
Notes [#notes]
* Category: Fitness
* Authentication mode: OAuth
# GitHub Integration
The GitHub integration provides access to manage GitHub repos, issues, and pull requests through the Integrate MCP server.
Installation [#installation]
The GitHub integration is included with the SDK:
```typescript
import { githubIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a GitHub OAuth App [#1-create-a-github-oauth-app]
1. Go to [GitHub Developer Settings](https://github.com/settings/developers)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the GitHub integration to your server configuration. The integration automatically reads `GITHUB_CLIENT_ID` and `GITHUB_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
githubIntegration({
clientId: process.env.CUSTOM_GITHUB_ID,
clientSecret: process.env.CUSTOM_GITHUB_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("github");
const result = await client.github.createIssue({
owner: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, githubIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [githubIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
github_create_issue [#github_create_issue]
Create a new issue in a repository
github_list_issues [#github_list_issues]
List issues in a repository
github_get_issue [#github_get_issue]
Get a specific issue
github_update_issue [#github_update_issue]
Update an existing issue
github_close_issue [#github_close_issue]
Close an issue
github_create_pull_request [#github_create_pull_request]
Create a pull request
github_list_pull_requests [#github_list_pull_requests]
List pull requests in a repository
github_get_pull_request [#github_get_pull_request]
Get a specific pull request
github_merge_pull_request [#github_merge_pull_request]
Merge a pull request
github_list_repos [#github_list_repos]
List repositories (for a user or organization)
github_list_own_repos [#github_list_own_repos]
List repositories for the authenticated user
github_get_repo [#github_get_repo]
Get a specific repository
github_create_repo [#github_create_repo]
Create a new repository
github_list_branches [#github_list_branches]
List branches in a repository
github_create_branch [#github_create_branch]
Create a new branch
github_get_authenticated_user [#github_get_authenticated_user]
Get information about the authenticated user
*No parameters.*
github_get_user [#github_get_user]
Get information about a user
github_list_commits [#github_list_commits]
List commits in a repository
github_get_commit [#github_get_commit]
Get a specific commit
github_list_issue_comments [#github_list_issue_comments]
List comments on an issue
github_add_issue_comment [#github_add_issue_comment]
Add a comment to an issue
github_update_issue_comment [#github_update_issue_comment]
Update an issue comment
github_delete_issue_comment [#github_delete_issue_comment]
Delete an issue comment
github_list_pr_files [#github_list_pr_files]
List pr files
*No parameters.*
github_list_pr_commits [#github_list_pr_commits]
List pr commits
*No parameters.*
github_list_pr_reviews [#github_list_pr_reviews]
List pr reviews
*No parameters.*
github_create_pr_review [#github_create_pr_review]
Create pr review
*No parameters.*
github_list_pr_review_comments [#github_list_pr_review_comments]
List pr review comments
*No parameters.*
github_get_file_contents [#github_get_file_contents]
Get the contents of a file or directory in a repository
github_create_or_update_file [#github_create_or_update_file]
Create or update a file in a repository
github_delete_file [#github_delete_file]
Delete a file from a repository
github_list_releases [#github_list_releases]
List releases in a repository
github_get_release [#github_get_release]
Get a specific release
github_get_latest_release [#github_get_latest_release]
Get the latest release for a repository
github_create_release [#github_create_release]
Create a release
github_list_labels [#github_list_labels]
List labels for a repository
github_create_label [#github_create_label]
Create a label in a repository
github_add_issue_labels [#github_add_issue_labels]
Add labels to an issue
github_list_collaborators [#github_list_collaborators]
List collaborators for a repository
github_fork_repo [#github_fork_repo]
Fork a repository
github_search_repos [#github_search_repos]
Search repositories
github_search_issues [#github_search_issues]
Search issues and pull requests
github_search_code [#github_search_code]
Search code
github_list_workflows [#github_list_workflows]
List workflows in a repository
github_list_workflow_runs [#github_list_workflow_runs]
List workflow runs for a repository or workflow
github_trigger_workflow [#github_trigger_workflow]
Trigger a workflow dispatch event
github_list_milestones [#github_list_milestones]
List milestones for a repository
github_create_milestone [#github_create_milestone]
Create a milestone
Notes [#notes]
* Category: Engineering
* Authentication mode: OAuth
# GitLab Integration
The GitLab integration provides access to manage GitLab projects, issues, merge requests, and CI/CD through the Integrate MCP server.
Installation [#installation]
The GitLab integration is included with the SDK:
```typescript
import { gitlabIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a GitLab OAuth App [#1-create-a-gitlab-oauth-app]
1. Create an OAuth application for GitLab
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the GitLab integration to your server configuration. The integration automatically reads `GITLAB_CLIENT_ID` and `GITLAB_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, gitlabIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
gitlabIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
gitlabIntegration({
clientId: process.env.CUSTOM_GITLAB_ID,
clientSecret: process.env.CUSTOM_GITLAB_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("gitlab");
// Use client.gitlab methods after connecting
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, gitlabIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [gitlabIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
gitlab_list_projects [#gitlab_list_projects]
List projects
*No parameters.*
gitlab_list_own_projects [#gitlab_list_own_projects]
List own projects
*No parameters.*
gitlab_get_project [#gitlab_get_project]
Get project
*No parameters.*
gitlab_create_project [#gitlab_create_project]
Create project
*No parameters.*
gitlab_create_issue [#gitlab_create_issue]
Create issue
*No parameters.*
gitlab_list_issues [#gitlab_list_issues]
List issues
*No parameters.*
gitlab_get_issue [#gitlab_get_issue]
Get issue
*No parameters.*
gitlab_update_issue [#gitlab_update_issue]
Update issue
*No parameters.*
gitlab_close_issue [#gitlab_close_issue]
Close issue
*No parameters.*
gitlab_create_merge_request [#gitlab_create_merge_request]
Create merge request
*No parameters.*
gitlab_list_merge_requests [#gitlab_list_merge_requests]
List merge requests
*No parameters.*
gitlab_get_merge_request [#gitlab_get_merge_request]
Get merge request
*No parameters.*
gitlab_accept_merge_request [#gitlab_accept_merge_request]
Accept merge request
*No parameters.*
gitlab_list_branches [#gitlab_list_branches]
List branches
*No parameters.*
gitlab_create_branch [#gitlab_create_branch]
Create branch
*No parameters.*
gitlab_list_commits [#gitlab_list_commits]
List commits
*No parameters.*
gitlab_get_commit [#gitlab_get_commit]
Get commit
*No parameters.*
gitlab_list_issue_notes [#gitlab_list_issue_notes]
List issue notes
*No parameters.*
gitlab_create_issue_note [#gitlab_create_issue_note]
Create issue note
*No parameters.*
gitlab_list_milestones [#gitlab_list_milestones]
List milestones
*No parameters.*
gitlab_create_milestone [#gitlab_create_milestone]
Create milestone
*No parameters.*
gitlab_get_current_user [#gitlab_get_current_user]
Get current user
*No parameters.*
Notes [#notes]
* Category: Engineering
* Authentication mode: OAuth
# Gmail Integration
The Gmail integration provides access to send, read, and search Gmail messages through the Integrate MCP server.
Installation [#installation]
The Gmail integration is included with the SDK:
```typescript
import { gmailIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Gmail OAuth App [#1-create-a-gmail-oauth-app]
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Gmail integration to your server configuration. The integration automatically reads `GMAIL_CLIENT_ID` and `GMAIL_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, gmailIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
gmailIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
gmailIntegration({
clientId: process.env.CUSTOM_GMAIL_ID,
clientSecret: process.env.CUSTOM_GMAIL_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("gmail");
const result = await client.gmail.sendMessage({
to: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, gmailIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [gmailIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
gmail_create_draft [#gmail_create_draft]
Create a draft message
gmail_get_attachment [#gmail_get_attachment]
Get a message attachment payload
gmail_get_message [#gmail_get_message]
Get a specific message by ID
gmail_get_thread [#gmail_get_thread]
Get a specific thread by ID
gmail_list_messages [#gmail_list_messages]
List messages in the mailbox
gmail_list_threads [#gmail_list_threads]
List threads in the mailbox
gmail_modify_message [#gmail_modify_message]
Modify labels on a message
gmail_reply_message [#gmail_reply_message]
Reply to a message in a thread
gmail_search_messages [#gmail_search_messages]
Search messages with query
gmail_send_message [#gmail_send_message]
Send a message
gmail_trash_message [#gmail_trash_message]
Move a message to trash
Notes [#notes]
* Category: Communication
* Authentication mode: OAuth
# GoCardless Integration
The GoCardless integration provides access to manage GoCardless institutions, requisitions, accounts, balances, and transactions through the Integrate MCP server.
Installation [#installation]
The GoCardless integration is included with the SDK:
```typescript
import { gocardlessIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a GoCardless OAuth App [#1-create-a-gocardless-oauth-app]
1. Create an OAuth application for GoCardless
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the GoCardless integration to your server configuration. The integration automatically reads `GOCARDLESS_CLIENT_ID` and `GOCARDLESS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, gocardlessIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
gocardlessIntegration({
scopes: ["openid", "accounts", "transactions", "balances"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
gocardlessIntegration({
clientId: process.env.CUSTOM_GOCARDLESS_ID,
clientSecret: process.env.CUSTOM_GOCARDLESS_SECRET,
scopes: ["openid", "accounts", "transactions", "balances"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("gocardless");
const result = await client.gocardless.listInstitutions({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, gocardlessIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [gocardlessIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `openid`
* `accounts`
* `transactions`
* `balances`
Tools [#tools]
gocardless_list_institutions [#gocardless_list_institutions]
List institutions
gocardless_create_requisition [#gocardless_create_requisition]
Create requisition
gocardless_get_requisition [#gocardless_get_requisition]
Get requisition
gocardless_get_account [#gocardless_get_account]
Get account
gocardless_get_balances [#gocardless_get_balances]
Get balances
gocardless_get_transactions [#gocardless_get_transactions]
Get transactions
Notes [#notes]
* Category: Banking
* Authentication mode: OAuth
# Google Ads Integration
The Google Ads integration provides access to manage Google Ads customers, campaigns, ad groups, ads, keywords, and conversions through the Integrate MCP server.
Installation [#installation]
The Google Ads integration is included with the SDK:
```typescript
import { googleAdsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Google Ads OAuth App [#1-create-a-google-ads-oauth-app]
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Google Ads integration to your server configuration. The integration automatically reads `GOOGLE_ADS_CLIENT_ID` and `GOOGLE_ADS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, googleAdsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
googleAdsIntegration({
scopes: ["https://www.googleapis.com/auth/adwords"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
googleAdsIntegration({
clientId: process.env.CUSTOM_GOOGLE_ADS_ID,
clientSecret: process.env.CUSTOM_GOOGLE_ADS_SECRET,
scopes: ["https://www.googleapis.com/auth/adwords"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("google_ads");
const result = await client.google_ads.listAccessibleCustomers({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, googleAdsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [googleAdsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `https://www.googleapis.com/auth/adwords`
Tools [#tools]
google_ads_list_accessible_customers [#google_ads_list_accessible_customers]
Ads list accessible customers
*No parameters.*
google_ads_search [#google_ads_search]
Ads search
google_ads_list_campaigns [#google_ads_list_campaigns]
Ads list campaigns
google_ads_list_ad_groups [#google_ads_list_ad_groups]
Ads list ad groups
google_ads_list_ads [#google_ads_list_ads]
Ads list ads
google_ads_list_keywords [#google_ads_list_keywords]
Ads list keywords
google_ads_list_conversions [#google_ads_list_conversions]
Ads list conversions
Notes [#notes]
* Category: Marketing
* Authentication mode: OAuth
# Google Analytics Integration
The Google Analytics integration provides access to read Google Analytics reports, properties, and events through the Integrate MCP server.
Installation [#installation]
The Google Analytics integration is included with the SDK:
```typescript
import { googleAnalyticsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Google Analytics OAuth App [#1-create-a-google-analytics-oauth-app]
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Google Analytics integration to your server configuration. The integration automatically reads `GOOGLE_ANALYTICS_CLIENT_ID` and `GOOGLE_ANALYTICS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, googleAnalyticsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
googleAnalyticsIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
googleAnalyticsIntegration({
clientId: process.env.CUSTOM_GOOGLE_ANALYTICS_ID,
clientSecret: process.env.CUSTOM_GOOGLE_ANALYTICS_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("google_analytics");
const result = await client.google_analytics.batchRunReports({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, googleAnalyticsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [googleAnalyticsIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
google_analytics_batch_run_reports [#google_analytics_batch_run_reports]
Analytics batch run reports
google_analytics_get_property [#google_analytics_get_property]
Analytics get property
google_analytics_list_account_summaries [#google_analytics_list_account_summaries]
Analytics list account summaries
google_analytics_run_realtime_report [#google_analytics_run_realtime_report]
Analytics run realtime report
google_analytics_run_report [#google_analytics_run_report]
Analytics run report
Notes [#notes]
* Category: Analytics
* Authentication mode: OAuth
# Google Calendar Integration
The Google Calendar integration provides access to manage Google Calendar events and schedules through the Integrate MCP server.
Installation [#installation]
The Google Calendar integration is included with the SDK:
```typescript
import { googleCalendarIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Google Calendar OAuth App [#1-create-a-google-calendar-oauth-app]
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Google Calendar integration to your server configuration. The integration automatically reads `GOOGLE_CALENDAR_CLIENT_ID` and `GOOGLE_CALENDAR_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, googleCalendarIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
googleCalendarIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
googleCalendarIntegration({
clientId: process.env.CUSTOM_GOOGLE_CALENDAR_ID,
clientSecret: process.env.CUSTOM_GOOGLE_CALENDAR_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("google_calendar");
const result = await client.google_calendar.listCalendars({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, googleCalendarIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [googleCalendarIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
google_calendar_create_calendar [#google_calendar_create_calendar]
Create a new calendar
google_calendar_create_event [#google_calendar_create_event]
Create a new event
google_calendar_delete_calendar [#google_calendar_delete_calendar]
Delete a calendar
google_calendar_delete_event [#google_calendar_delete_event]
Delete an event
google_calendar_freebusy [#google_calendar_freebusy]
Calendar freebusy
google_calendar_get_calendar [#google_calendar_get_calendar]
Get a specific calendar
google_calendar_get_event [#google_calendar_get_event]
Get a specific event
google_calendar_list_attendees [#google_calendar_list_attendees]
List attendees for an event
google_calendar_list_calendars [#google_calendar_list_calendars]
List calendars
google_calendar_list_events [#google_calendar_list_events]
List events in a calendar
google_calendar_quick_add [#google_calendar_quick_add]
Quickly add an event using natural language
google_calendar_update_event [#google_calendar_update_event]
Update an existing event
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Google Chat Integration
The Google Chat integration provides access to list Google Chat spaces and manage messages and memberships through the Integrate MCP server.
Installation [#installation]
The Google Chat integration is included with the SDK:
```typescript
import { googleChatIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Google Chat OAuth App [#1-create-a-google-chat-oauth-app]
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Google Chat integration to your server configuration. The integration automatically reads `GOOGLE_CHAT_CLIENT_ID` and `GOOGLE_CHAT_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, googleChatIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
googleChatIntegration({
scopes: ["https://www.googleapis.com/auth/chat.messages", "https://www.googleapis.com/auth/chat.spaces.readonly"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
googleChatIntegration({
clientId: process.env.CUSTOM_GOOGLE_CHAT_ID,
clientSecret: process.env.CUSTOM_GOOGLE_CHAT_SECRET,
scopes: ["https://www.googleapis.com/auth/chat.messages", "https://www.googleapis.com/auth/chat.spaces.readonly"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("google_chat");
const result = await client.google_chat.deleteMessage({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, googleChatIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [googleChatIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `https://www.googleapis.com/auth/chat.messages`
* `https://www.googleapis.com/auth/chat.spaces.readonly`
Tools [#tools]
google_chat_delete_message [#google_chat_delete_message]
Chat delete message
google_chat_get_message [#google_chat_get_message]
Chat get message
google_chat_get_space [#google_chat_get_space]
Chat get space
google_chat_list_members [#google_chat_list_members]
Chat list members
google_chat_list_messages [#google_chat_list_messages]
Chat list messages
google_chat_list_spaces [#google_chat_list_spaces]
Chat list spaces
google_chat_send_message [#google_chat_send_message]
Chat send message
google_chat_update_message [#google_chat_update_message]
Chat update message
Notes [#notes]
* Category: Communication
* Authentication mode: OAuth
# Google Classroom Integration
The Google Classroom integration provides access to manage Google Classroom list courses, get course, create course, list coursework, create coursework through the Integrate MCP server.
Installation [#installation]
The Google Classroom integration is included with the SDK:
```typescript
import { googleClassroomIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Google Classroom OAuth App [#1-create-a-google-classroom-oauth-app]
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Google Classroom integration to your server configuration. The integration automatically reads `GOOGLE_CLASSROOM_CLIENT_ID` and `GOOGLE_CLASSROOM_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, googleClassroomIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
googleClassroomIntegration({
scopes: ["https://www.googleapis.com/auth/classroom.courses", "https://www.googleapis.com/auth/classroom.coursework.me", "https://www.googleapis.com/auth/classroom.rosters", "https://www.googleapis.com/auth/classroom.profile.emails"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
googleClassroomIntegration({
clientId: process.env.CUSTOM_GOOGLE_CLASSROOM_ID,
clientSecret: process.env.CUSTOM_GOOGLE_CLASSROOM_SECRET,
scopes: ["https://www.googleapis.com/auth/classroom.courses", "https://www.googleapis.com/auth/classroom.coursework.me", "https://www.googleapis.com/auth/classroom.rosters", "https://www.googleapis.com/auth/classroom.profile.emails"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("google_classroom");
const result = await client.google_classroom.listCourses({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, googleClassroomIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [googleClassroomIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `https://www.googleapis.com/auth/classroom.courses`
* `https://www.googleapis.com/auth/classroom.coursework.me`
* `https://www.googleapis.com/auth/classroom.rosters`
* `https://www.googleapis.com/auth/classroom.profile.emails`
Tools [#tools]
google_classroom_list_courses [#google_classroom_list_courses]
Classroom list courses
google_classroom_get_course [#google_classroom_get_course]
Classroom get course
google_classroom_create_course [#google_classroom_create_course]
Classroom create course
google_classroom_list_coursework [#google_classroom_list_coursework]
Classroom list coursework
google_classroom_create_coursework [#google_classroom_create_coursework]
Classroom create coursework
google_classroom_list_students [#google_classroom_list_students]
Classroom list students
Notes [#notes]
* Category: Education
* Authentication mode: OAuth
# Google Contacts Integration
The Google Contacts integration provides access to list, search, create, update, and delete Google Contacts via the People API through the Integrate MCP server.
Installation [#installation]
The Google Contacts integration is included with the SDK:
```typescript
import { googleContactsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Google Contacts OAuth App [#1-create-a-google-contacts-oauth-app]
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Google Contacts integration to your server configuration. The integration automatically reads `GOOGLE_CONTACTS_CLIENT_ID` and `GOOGLE_CONTACTS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, googleContactsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
googleContactsIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
googleContactsIntegration({
clientId: process.env.CUSTOM_GOOGLE_CONTACTS_ID,
clientSecret: process.env.CUSTOM_GOOGLE_CONTACTS_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("google_contacts");
const result = await client.google_contacts.batchGetContacts({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, googleContactsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [googleContactsIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
google_contacts_batch_get_contacts [#google_contacts_batch_get_contacts]
Contacts batch get contacts
google_contacts_copy_other_contact [#google_contacts_copy_other_contact]
Contacts copy other contact
google_contacts_create_contact [#google_contacts_create_contact]
Contacts create contact
google_contacts_delete_contact [#google_contacts_delete_contact]
Contacts delete contact
google_contacts_get_person [#google_contacts_get_person]
Contacts get person
google_contacts_get_self [#google_contacts_get_self]
Contacts get self
google_contacts_list_connections [#google_contacts_list_connections]
Contacts list connections
google_contacts_list_other_contacts [#google_contacts_list_other_contacts]
Contacts list other contacts
google_contacts_search_contacts [#google_contacts_search_contacts]
Contacts search contacts
google_contacts_update_contact [#google_contacts_update_contact]
Contacts update contact
Notes [#notes]
* Category: Communication
* Authentication mode: OAuth
# Google Docs Integration
The Google Docs integration provides access to create and edit Google Docs documents through the Integrate MCP server.
Installation [#installation]
The Google Docs integration is included with the SDK:
```typescript
import { googleDocsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Google Docs OAuth App [#1-create-a-google-docs-oauth-app]
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Google Docs integration to your server configuration. The integration automatically reads `GOOGLE_DOCS_CLIENT_ID` and `GOOGLE_DOCS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, googleDocsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
googleDocsIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
googleDocsIntegration({
clientId: process.env.CUSTOM_GOOGLE_DOCS_ID,
clientSecret: process.env.CUSTOM_GOOGLE_DOCS_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("google_docs");
const result = await client.google_docs.list({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, googleDocsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [googleDocsIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
google_docs_append_text [#google_docs_append_text]
Docs append text
google_docs_batch_update [#google_docs_batch_update]
Docs batch update
google_docs_create [#google_docs_create]
Docs create
google_docs_create_comment [#google_docs_create_comment]
Docs create comment
google_docs_delete [#google_docs_delete]
Docs delete
google_docs_delete_comment [#google_docs_delete_comment]
Docs delete comment
google_docs_get [#google_docs_get]
Docs get
google_docs_list [#google_docs_list]
Docs list
google_docs_list_comments [#google_docs_list_comments]
Docs list comments
google_docs_replace_text [#google_docs_replace_text]
Docs replace text
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Google Drive Integration
The Google Drive integration provides access to manage Google Drive files, folders, and sharing through the Integrate MCP server.
Installation [#installation]
The Google Drive integration is included with the SDK:
```typescript
import { googleDriveIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Google Drive OAuth App [#1-create-a-google-drive-oauth-app]
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Google Drive integration to your server configuration. The integration automatically reads `GOOGLE_DRIVE_CLIENT_ID` and `GOOGLE_DRIVE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, googleDriveIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
googleDriveIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
googleDriveIntegration({
clientId: process.env.CUSTOM_GOOGLE_DRIVE_ID,
clientSecret: process.env.CUSTOM_GOOGLE_DRIVE_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("google_drive");
const result = await client.google_drive.listFiles({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, googleDriveIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [googleDriveIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
google_drive_copy_file [#google_drive_copy_file]
Copy a file
google_drive_create_folder [#google_drive_create_folder]
Create a new folder
google_drive_delete_file [#google_drive_delete_file]
Permanently delete a file or folder (not recoverable)
google_drive_download_file [#google_drive_download_file]
Download file content as text. Google Workspace files are auto-exported.
google_drive_get_about [#google_drive_get_about]
Get current user info and storage quota
*No parameters.*
google_drive_get_file [#google_drive_get_file]
Get metadata for a file or folder
google_drive_list_files [#google_drive_list_files]
List files and folders in Google Drive
google_drive_list_permissions [#google_drive_list_permissions]
List sharing permissions on a file or folder
google_drive_move_file [#google_drive_move_file]
Move a file or folder to a different parent
google_drive_remove_permission [#google_drive_remove_permission]
Remove a sharing permission
google_drive_rename_file [#google_drive_rename_file]
Rename a file or folder
google_drive_share_file [#google_drive_share_file]
Share a file or folder
google_drive_trash_file [#google_drive_trash_file]
Move a file or folder to trash (recoverable)
google_drive_upload_text_file [#google_drive_upload_text_file]
Create a new file with text content
Notes [#notes]
* Category: Storage
* Authentication mode: OAuth
# Google Forms Integration
The Google Forms integration provides access to manage Google Forms forms, structure updates, and responses through the Integrate MCP server.
Installation [#installation]
The Google Forms integration is included with the SDK:
```typescript
import { googleFormsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Google Forms OAuth App [#1-create-a-google-forms-oauth-app]
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Google Forms integration to your server configuration. The integration automatically reads `GOOGLE_FORMS_CLIENT_ID` and `GOOGLE_FORMS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, googleFormsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
googleFormsIntegration({
scopes: ["openid", "email", "https://www.googleapis.com/auth/forms.body", "https://www.googleapis.com/auth/forms.responses.readonly", "https://www.googleapis.com/auth/drive.readonly"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
googleFormsIntegration({
clientId: process.env.CUSTOM_GOOGLE_FORMS_ID,
clientSecret: process.env.CUSTOM_GOOGLE_FORMS_SECRET,
scopes: ["openid", "email", "https://www.googleapis.com/auth/forms.body", "https://www.googleapis.com/auth/forms.responses.readonly", "https://www.googleapis.com/auth/drive.readonly"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("google_forms");
const result = await client.google_forms.createForm({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, googleFormsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [googleFormsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `openid`
* `email`
* `https://www.googleapis.com/auth/forms.body`
* `https://www.googleapis.com/auth/forms.responses.readonly`
* `https://www.googleapis.com/auth/drive.readonly`
Tools [#tools]
google_forms_create_form [#google_forms_create_form]
Forms create form
google_forms_get_form [#google_forms_get_form]
Forms get form
google_forms_batch_update_form [#google_forms_batch_update_form]
Forms batch update form
google_forms_list_form_responses [#google_forms_list_form_responses]
Forms list form responses
google_forms_get_form_response [#google_forms_get_form_response]
Forms get form response
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Google Home Integration
The Google Home integration provides access to manage Google Home devices, structures, rooms, and device commands through the Integrate MCP server.
Installation [#installation]
The Google Home integration is included with the SDK:
```typescript
import { googleHomeIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Google Home OAuth App [#1-create-a-google-home-oauth-app]
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Google Home integration to your server configuration. The integration automatically reads `GOOGLE_HOME_CLIENT_ID` and `GOOGLE_HOME_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, googleHomeIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
googleHomeIntegration({
scopes: ["https://www.googleapis.com/auth/sdm.service"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
googleHomeIntegration({
clientId: process.env.CUSTOM_GOOGLE_HOME_ID,
clientSecret: process.env.CUSTOM_GOOGLE_HOME_SECRET,
scopes: ["https://www.googleapis.com/auth/sdm.service"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("google_home");
const result = await client.google_home.listDevices({
project_id: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, googleHomeIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [googleHomeIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `https://www.googleapis.com/auth/sdm.service`
Tools [#tools]
google_home_list_devices [#google_home_list_devices]
Home list devices
google_home_get_device [#google_home_get_device]
Home get device
google_home_execute_device_command [#google_home_execute_device_command]
Home execute device command
google_home_list_structures [#google_home_list_structures]
Home list structures
google_home_list_rooms [#google_home_list_rooms]
Home list rooms
Notes [#notes]
* Category: Lifestyle
* Authentication mode: OAuth
# Google Keep Integration
The Google Keep integration provides access to manage Google Keep notes, attachments, and sharing permissions through the Integrate MCP server.
Installation [#installation]
The Google Keep integration is included with the SDK:
```typescript
import { googleKeepIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Google Keep OAuth App [#1-create-a-google-keep-oauth-app]
1. Create an OAuth application for Google Keep
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Google Keep integration to your server configuration. The integration automatically reads `GOOGLE_KEEP_CLIENT_ID` and `GOOGLE_KEEP_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, googleKeepIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
googleKeepIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
googleKeepIntegration({
clientId: process.env.CUSTOM_GOOGLE_KEEP_ID,
clientSecret: process.env.CUSTOM_GOOGLE_KEEP_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("google_keep");
const result = await client.google_keep.listNotes({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, googleKeepIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [googleKeepIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
google_keep_list_notes [#google_keep_list_notes]
Keep list notes
google_keep_get_note [#google_keep_get_note]
Keep get note
google_keep_create_text_note [#google_keep_create_text_note]
Keep create text note
google_keep_create_list_note [#google_keep_create_list_note]
Keep create list note
google_keep_delete_note [#google_keep_delete_note]
Keep delete note
google_keep_download_attachment [#google_keep_download_attachment]
Keep download attachment
google_keep_batch_create_permissions [#google_keep_batch_create_permissions]
Keep batch create permissions
google_keep_batch_delete_permissions [#google_keep_batch_delete_permissions]
Keep batch delete permissions
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Google Meet Integration
The Google Meet integration provides access to create and manage Google Meet links via Calendar conference data through the Integrate MCP server.
Installation [#installation]
The Google Meet integration is included with the SDK:
```typescript
import { googleMeetIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Google Meet OAuth App [#1-create-a-google-meet-oauth-app]
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Google Meet integration to your server configuration. The integration automatically reads `GOOGLE_MEET_CLIENT_ID` and `GOOGLE_MEET_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, googleMeetIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
googleMeetIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
googleMeetIntegration({
clientId: process.env.CUSTOM_GOOGLE_MEET_ID,
clientSecret: process.env.CUSTOM_GOOGLE_MEET_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("google_meet");
const result = await client.google_meet.addMeetToEvent({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, googleMeetIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [googleMeetIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
google_meet_add_meet_to_event [#google_meet_add_meet_to_event]
Meet add meet to event
google_meet_create_meeting [#google_meet_create_meeting]
Meet create meeting
google_meet_delete_meeting [#google_meet_delete_meeting]
Meet delete meeting
google_meet_get_meeting [#google_meet_get_meeting]
Meet get meeting
google_meet_list_meetings [#google_meet_list_meetings]
Meet list meetings
google_meet_update_meeting [#google_meet_update_meeting]
Meet update meeting
Notes [#notes]
* Category: Communication
* Authentication mode: OAuth
# Google Play Console Integration
The Google Play Console integration provides access to manage Google Play edits, tracks, and in-app products through the Android Publisher API through the Integrate MCP server.
Installation [#installation]
The Google Play Console integration is included with the SDK:
```typescript
import { googlePlayConsoleIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Google Play Console OAuth App [#1-create-a-google-play-console-oauth-app]
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Google Play Console integration to your server configuration. The integration automatically reads `GOOGLE_PLAY_CONSOLE_CLIENT_ID` and `GOOGLE_PLAY_CONSOLE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, googlePlayConsoleIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
googlePlayConsoleIntegration({
scopes: ["openid", "email", "https://www.googleapis.com/auth/androidpublisher"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
googlePlayConsoleIntegration({
clientId: process.env.CUSTOM_GOOGLE_PLAY_CONSOLE_ID,
clientSecret: process.env.CUSTOM_GOOGLE_PLAY_CONSOLE_SECRET,
scopes: ["openid", "email", "https://www.googleapis.com/auth/androidpublisher"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("google_play_console");
const result = await client.google_play_console.insertEdit({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, googlePlayConsoleIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [googlePlayConsoleIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `openid`
* `email`
* `https://www.googleapis.com/auth/androidpublisher`
Tools [#tools]
google_play_console_insert_edit [#google_play_console_insert_edit]
Play console insert edit
google_play_console_get_edit [#google_play_console_get_edit]
Play console get edit
google_play_console_list_tracks [#google_play_console_list_tracks]
Play console list tracks
google_play_console_update_track [#google_play_console_update_track]
Play console update track
google_play_console_commit_edit [#google_play_console_commit_edit]
Play console commit edit
google_play_console_list_in_app_products [#google_play_console_list_in_app_products]
Play console list in app products
Notes [#notes]
* Category: Engineering
* Authentication mode: OAuth
# Google Sheets Integration
The Google Sheets integration provides access to read and update Google Sheets spreadsheets through the Integrate MCP server.
Installation [#installation]
The Google Sheets integration is included with the SDK:
```typescript
import { googleSheetsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Google Sheets OAuth App [#1-create-a-google-sheets-oauth-app]
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Google Sheets integration to your server configuration. The integration automatically reads `GOOGLE_SHEETS_CLIENT_ID` and `GOOGLE_SHEETS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, googleSheetsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
googleSheetsIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
googleSheetsIntegration({
clientId: process.env.CUSTOM_GOOGLE_SHEETS_ID,
clientSecret: process.env.CUSTOM_GOOGLE_SHEETS_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("google_sheets");
const result = await client.google_sheets.list({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, googleSheetsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [googleSheetsIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
google_sheets_append_values [#google_sheets_append_values]
Sheets append values
google_sheets_batch_update [#google_sheets_batch_update]
Sheets batch update
google_sheets_batch_update_values [#google_sheets_batch_update_values]
Sheets batch update values
google_sheets_clear_values [#google_sheets_clear_values]
Sheets clear values
google_sheets_create [#google_sheets_create]
Sheets create
google_sheets_delete [#google_sheets_delete]
Sheets delete
google_sheets_get [#google_sheets_get]
Sheets get
google_sheets_get_values [#google_sheets_get_values]
Sheets get values
google_sheets_list [#google_sheets_list]
Sheets list
google_sheets_update_values [#google_sheets_update_values]
Sheets update values
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Google Slides Integration
The Google Slides integration provides access to create and update Google Slides presentations through the Integrate MCP server.
Installation [#installation]
The Google Slides integration is included with the SDK:
```typescript
import { googleSlidesIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Google Slides OAuth App [#1-create-a-google-slides-oauth-app]
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Google Slides integration to your server configuration. The integration automatically reads `GOOGLE_SLIDES_CLIENT_ID` and `GOOGLE_SLIDES_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, googleSlidesIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
googleSlidesIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
googleSlidesIntegration({
clientId: process.env.CUSTOM_GOOGLE_SLIDES_ID,
clientSecret: process.env.CUSTOM_GOOGLE_SLIDES_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("google_slides");
const result = await client.google_slides.list({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, googleSlidesIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [googleSlidesIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
google_slides_add_slide [#google_slides_add_slide]
Slides add slide
google_slides_batch_update [#google_slides_batch_update]
Slides batch update
google_slides_create [#google_slides_create]
Slides create
google_slides_delete [#google_slides_delete]
Slides delete
google_slides_delete_slide [#google_slides_delete_slide]
Slides delete slide
google_slides_get [#google_slides_get]
Slides get
google_slides_get_page [#google_slides_get_page]
Slides get page
google_slides_list [#google_slides_list]
Slides list
google_slides_update_text [#google_slides_update_text]
Slides update text
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Google Tasks Integration
The Google Tasks integration provides access to manage Google Tasks lists and to-dos synced with your Google account through the Integrate MCP server.
Installation [#installation]
The Google Tasks integration is included with the SDK:
```typescript
import { googleTasksIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Google Tasks OAuth App [#1-create-a-google-tasks-oauth-app]
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Google Tasks integration to your server configuration. The integration automatically reads `GOOGLE_TASKS_CLIENT_ID` and `GOOGLE_TASKS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, googleTasksIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
googleTasksIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
googleTasksIntegration({
clientId: process.env.CUSTOM_GOOGLE_TASKS_ID,
clientSecret: process.env.CUSTOM_GOOGLE_TASKS_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("google_tasks");
const result = await client.google_tasks.clearCompleted({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, googleTasksIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [googleTasksIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
google_tasks_clear_completed [#google_tasks_clear_completed]
Tasks clear completed
google_tasks_create_task [#google_tasks_create_task]
Tasks create task
google_tasks_create_tasklist [#google_tasks_create_tasklist]
Tasks create tasklist
google_tasks_delete_task [#google_tasks_delete_task]
Tasks delete task
google_tasks_delete_tasklist [#google_tasks_delete_tasklist]
Tasks delete tasklist
google_tasks_get_task [#google_tasks_get_task]
Tasks get task
google_tasks_get_tasklist [#google_tasks_get_tasklist]
Tasks get tasklist
google_tasks_list_tasklists [#google_tasks_list_tasklists]
Tasks list tasklists
google_tasks_list_tasks [#google_tasks_list_tasks]
Tasks list tasks
google_tasks_move_task [#google_tasks_move_task]
Tasks move task
google_tasks_update_task [#google_tasks_update_task]
Tasks update task
google_tasks_update_tasklist [#google_tasks_update_tasklist]
Tasks update tasklist
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Granola Integration
The Granola integration provides access to list and read Granola meeting notes and folders through the Integrate MCP server.
Installation [#installation]
The Granola integration is included with the SDK:
```typescript
import { granolaIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Granola to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, granolaIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
granolaIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
// Use client.granola methods after connecting
```
Environment Variables [#environment-variables]
* `GRANOLA_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
granola_list_notes [#granola_list_notes]
List notes
*No parameters.*
granola_get_note [#granola_get_note]
Get note
*No parameters.*
granola_list_folders [#granola_list_folders]
List folders
*No parameters.*
Notes [#notes]
* Category: Productivity
* Authentication mode: API key
# Greenhouse Integration
The Greenhouse integration provides access to manage Greenhouse list candidates, get candidate, create candidate, list jobs, list applications through the Integrate MCP server.
Installation [#installation]
The Greenhouse integration is included with the SDK:
```typescript
import { greenhouseIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Greenhouse OAuth App [#1-create-a-greenhouse-oauth-app]
1. Create an OAuth application for Greenhouse
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Greenhouse integration to your server configuration. The integration automatically reads `GREENHOUSE_CLIENT_ID` and `GREENHOUSE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, greenhouseIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
greenhouseIntegration({
scopes: ["candidates:read", "candidates:write", "jobs:read", "applications:read", "users:read"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
greenhouseIntegration({
clientId: process.env.CUSTOM_GREENHOUSE_ID,
clientSecret: process.env.CUSTOM_GREENHOUSE_SECRET,
scopes: ["candidates:read", "candidates:write", "jobs:read", "applications:read", "users:read"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("greenhouse");
const result = await client.greenhouse.listCandidates({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, greenhouseIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [greenhouseIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `candidates:read`
* `candidates:write`
* `jobs:read`
* `applications:read`
* `users:read`
Tools [#tools]
greenhouse_list_candidates [#greenhouse_list_candidates]
List candidates
greenhouse_get_candidate [#greenhouse_get_candidate]
Get candidate
greenhouse_create_candidate [#greenhouse_create_candidate]
Create candidate
greenhouse_list_jobs [#greenhouse_list_jobs]
List jobs
greenhouse_list_applications [#greenhouse_list_applications]
List applications
greenhouse_list_users [#greenhouse_list_users]
List users
Notes [#notes]
* Category: HR & Recruiting
* Authentication mode: OAuth
# Home Connect Integration
The Home Connect integration provides access to manage Home Connect list appliances, get appliance, get status, get programs, start program through the Integrate MCP server.
Installation [#installation]
The Home Connect integration is included with the SDK:
```typescript
import { homeConnectIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Home Connect OAuth App [#1-create-a-home-connect-oauth-app]
1. Create an OAuth application for Home Connect
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Home Connect integration to your server configuration. The integration automatically reads `HOME_CONNECT_CLIENT_ID` and `HOME_CONNECT_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, homeConnectIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
homeConnectIntegration({
scopes: ["IdentifyAppliance", "Monitor", "Settings", "Control"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
homeConnectIntegration({
clientId: process.env.CUSTOM_HOME_CONNECT_ID,
clientSecret: process.env.CUSTOM_HOME_CONNECT_SECRET,
scopes: ["IdentifyAppliance", "Monitor", "Settings", "Control"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("home_connect");
const result = await client.home_connect.listAppliances({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, homeConnectIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [homeConnectIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `IdentifyAppliance`
* `Monitor`
* `Settings`
* `Control`
Tools [#tools]
home_connect_list_appliances [#home_connect_list_appliances]
Connect list appliances
*No parameters.*
home_connect_get_appliance [#home_connect_get_appliance]
Connect get appliance
home_connect_get_status [#home_connect_get_status]
Connect get status
home_connect_get_programs [#home_connect_get_programs]
Connect get programs
home_connect_start_program [#home_connect_start_program]
Connect start program
home_connect_set_setting [#home_connect_set_setting]
Connect set setting
Notes [#notes]
* Category: Lifestyle
* Authentication mode: OAuth
# HubSpot Integration
The HubSpot integration provides access to manage HubSpot contacts, deals, and tickets through the Integrate MCP server.
Installation [#installation]
The HubSpot integration is included with the SDK:
```typescript
import { hubspotIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a HubSpot OAuth App [#1-create-a-hubspot-oauth-app]
1. Go to [HubSpot Developer Apps](https://app.hubspot.com/developers)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the HubSpot integration to your server configuration. The integration automatically reads `HUBSPOT_CLIENT_ID` and `HUBSPOT_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, hubspotIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
hubspotIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
hubspotIntegration({
clientId: process.env.CUSTOM_HUBSPOT_ID,
clientSecret: process.env.CUSTOM_HUBSPOT_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("hubspot");
const result = await client.hubspot.listContacts({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, hubspotIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [hubspotIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
hubspot_list_contacts [#hubspot_list_contacts]
List contacts
hubspot_get_contact [#hubspot_get_contact]
Get contact
hubspot_create_contact [#hubspot_create_contact]
Create contact
hubspot_update_contact [#hubspot_update_contact]
Update contact
hubspot_delete_contact [#hubspot_delete_contact]
Delete contact
hubspot_list_companies [#hubspot_list_companies]
List companies
hubspot_get_company [#hubspot_get_company]
Get company
hubspot_create_company [#hubspot_create_company]
Create company
hubspot_update_company [#hubspot_update_company]
Update company
hubspot_delete_company [#hubspot_delete_company]
Delete company
hubspot_list_deals [#hubspot_list_deals]
List deals
hubspot_get_deal [#hubspot_get_deal]
Get deal
hubspot_create_deal [#hubspot_create_deal]
Create deal
hubspot_update_deal [#hubspot_update_deal]
Update deal
hubspot_delete_deal [#hubspot_delete_deal]
Delete deal
hubspot_list_tickets [#hubspot_list_tickets]
List tickets
hubspot_get_ticket [#hubspot_get_ticket]
Get ticket
hubspot_create_ticket [#hubspot_create_ticket]
Create ticket
hubspot_update_ticket [#hubspot_update_ticket]
Update ticket
hubspot_delete_ticket [#hubspot_delete_ticket]
Delete ticket
hubspot_search_crm [#hubspot_search_crm]
Search crm
hubspot_create_note [#hubspot_create_note]
Create note
hubspot_create_task [#hubspot_create_task]
Create task
hubspot_list_owners [#hubspot_list_owners]
List owners
hubspot_get_owner [#hubspot_get_owner]
Get owner
hubspot_list_pipelines [#hubspot_list_pipelines]
List pipelines
hubspot_list_pipeline_stages [#hubspot_list_pipeline_stages]
List pipeline stages
hubspot_create_association [#hubspot_create_association]
Create association
Notes [#notes]
* Category: Business
* Authentication mode: OAuth
# Integrations
import { Cards, Card } from "fumadocs-ui/components/card";
The Integrate MCP server exposes tools for 200+ third-party services. Each integration has its own OAuth configuration, scopes, and typed tools in the SDK.
Browse the sidebar for a specific provider, or start with the most common ones below.
Full catalog [#full-catalog]
See the [integrations directory](/integrations) on the marketing site for logos and search, or use the docs sidebar for per-integration setup guides.
Custom integrations [#custom-integrations]
New providers are added on the [Integrate MCP server](https://github.com/integratedotdev/mcp-server). If you need a provider that is not listed yet, open an issue or contribute an integration following the patterns in that repository.
# Instagram Integration
The Instagram integration provides access to instagram Graph API for professional accounts β pages, media, comments, insights, stories, and publishing. through the Integrate MCP server.
Installation [#installation]
The Instagram integration is included with the SDK:
```typescript
import { instagramIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Instagram OAuth App [#1-create-an-instagram-oauth-app]
1. Go to [Facebook Developer Portal](https://www.facebook.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Instagram integration to your server configuration. The integration automatically reads `INSTAGRAM_CLIENT_ID` and `INSTAGRAM_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, instagramIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
instagramIntegration({
scopes: ["pages_show_list", "pages_read_engagement", "instagram_basic", "instagram_manage_insights", "instagram_manage_comments", "instagram_content_publish"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
instagramIntegration({
clientId: process.env.CUSTOM_INSTAGRAM_ID,
clientSecret: process.env.CUSTOM_INSTAGRAM_SECRET,
scopes: ["pages_show_list", "pages_read_engagement", "instagram_basic", "instagram_manage_insights", "instagram_manage_comments", "instagram_content_publish"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("instagram");
const result = await client.instagram.listPages({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, instagramIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [instagramIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `pages_show_list`
* `pages_read_engagement`
* `instagram_basic`
* `instagram_manage_insights`
* `instagram_manage_comments`
* `instagram_content_publish`
Tools [#tools]
instagram_list_pages [#instagram_list_pages]
List pages
instagram_get_profile [#instagram_get_profile]
Get profile
instagram_list_media [#instagram_list_media]
List media
instagram_get_media [#instagram_get_media]
Get media
instagram_list_comments [#instagram_list_comments]
List comments
instagram_reply_comment [#instagram_reply_comment]
Reply comment
instagram_delete_comment [#instagram_delete_comment]
Delete comment
instagram_hide_comment [#instagram_hide_comment]
Hide comment
instagram_get_media_insights [#instagram_get_media_insights]
Get media insights
instagram_get_user_insights [#instagram_get_user_insights]
Get user insights
instagram_create_media_container [#instagram_create_media_container]
Create media container
instagram_publish_media [#instagram_publish_media]
Publish media
instagram_list_stories [#instagram_list_stories]
List stories
instagram_list_tagged_media [#instagram_list_tagged_media]
List tagged media
Notes [#notes]
* Category: Social Media
* Authentication mode: OAuth
# Intercom Integration
The Intercom integration provides access to manage Intercom contacts and conversations through the Integrate MCP server.
Installation [#installation]
The Intercom integration is included with the SDK:
```typescript
import { intercomIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Intercom OAuth App [#1-create-an-intercom-oauth-app]
1. Go to [Intercom Developer Hub](https://developers.intercom.com/)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Intercom integration to your server configuration. The integration automatically reads `INTERCOM_CLIENT_ID` and `INTERCOM_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, intercomIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
intercomIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
intercomIntegration({
clientId: process.env.CUSTOM_INTERCOM_ID,
clientSecret: process.env.CUSTOM_INTERCOM_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("intercom");
const result = await client.intercom.listContacts({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, intercomIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [intercomIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
intercom_list_contacts [#intercom_list_contacts]
List contacts
intercom_get_contact [#intercom_get_contact]
Get contact details
intercom_create_contact [#intercom_create_contact]
Create a new contact
intercom_list_conversations [#intercom_list_conversations]
List conversations
intercom_get_conversation [#intercom_get_conversation]
Get conversation details
intercom_reply_conversation [#intercom_reply_conversation]
Reply to a conversation
intercom_list_companies [#intercom_list_companies]
List companies
intercom_get_company [#intercom_get_company]
Get company details
intercom_search_contacts [#intercom_search_contacts]
Search for contacts
Notes [#notes]
* Category: Business
* Authentication mode: OAuth
# Jira Integration
The Jira integration provides access to manage Jira issues, projects, sprints, and boards through the Integrate MCP server.
Installation [#installation]
The Jira integration is included with the SDK:
```typescript
import { jiraIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Jira OAuth App [#1-create-a-jira-oauth-app]
1. Go to [Auth Developer Portal](https://auth.atlassian.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Jira integration to your server configuration. The integration automatically reads `JIRA_CLIENT_ID` and `JIRA_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, jiraIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
jiraIntegration({
scopes: ["read:jira-work", "write:jira-work", "read:account", "offline_access"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
jiraIntegration({
clientId: process.env.CUSTOM_JIRA_ID,
clientSecret: process.env.CUSTOM_JIRA_SECRET,
scopes: ["read:jira-work", "write:jira-work", "read:account", "offline_access"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("jira");
const result = await client.jira.listProjects({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, jiraIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [jiraIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `read:jira-work`
* `write:jira-work`
* `read:account`
* `offline_access`
Tools [#tools]
jira_list_projects [#jira_list_projects]
List projects
jira_get_project [#jira_get_project]
Get project
jira_get_issue_types [#jira_get_issue_types]
Get issue types
jira_search_issues [#jira_search_issues]
Search issues
jira_get_issue [#jira_get_issue]
Get issue
jira_create_issue [#jira_create_issue]
Create issue
jira_update_issue [#jira_update_issue]
Update issue
jira_get_transitions [#jira_get_transitions]
Get transitions
jira_transition_issue [#jira_transition_issue]
Transition issue
jira_add_comment [#jira_add_comment]
Add comment
jira_assign_issue [#jira_assign_issue]
Assign issue
jira_list_boards [#jira_list_boards]
List boards
jira_list_sprints [#jira_list_sprints]
List sprints
Notes [#notes]
* Category: Engineering
* Authentication mode: OAuth
# Kick Integration
The Kick integration provides access to manage Kick get users, get channels, get livestreams, get categories, send chat message through the Integrate MCP server.
Installation [#installation]
The Kick integration is included with the SDK:
```typescript
import { kickIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Kick OAuth App [#1-create-a-kick-oauth-app]
1. Create an OAuth application for Kick
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Kick integration to your server configuration. The integration automatically reads `KICK_CLIENT_ID` and `KICK_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, kickIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
kickIntegration({
scopes: ["user:read", "channel:read", "channel:write", "chat:write", "events:subscribe"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
kickIntegration({
clientId: process.env.CUSTOM_KICK_ID,
clientSecret: process.env.CUSTOM_KICK_SECRET,
scopes: ["user:read", "channel:read", "channel:write", "chat:write", "events:subscribe"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("kick");
const result = await client.kick.getUsers({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, kickIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [kickIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `user:read`
* `channel:read`
* `channel:write`
* `chat:write`
* `events:subscribe`
Tools [#tools]
kick_get_users [#kick_get_users]
Get users
kick_get_channels [#kick_get_channels]
Get channels
kick_get_livestreams [#kick_get_livestreams]
Get livestreams
kick_get_categories [#kick_get_categories]
Get categories
kick_send_chat_message [#kick_send_chat_message]
Send chat message
Notes [#notes]
* Category: Entertainment
* Authentication mode: OAuth
# Klaviyo Integration
The Klaviyo integration provides access to manage Klaviyo accounts, profiles, lists, segments, campaigns, and metrics through the Integrate MCP server.
Installation [#installation]
The Klaviyo integration is included with the SDK:
```typescript
import { klaviyoIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Klaviyo OAuth App [#1-create-a-klaviyo-oauth-app]
1. Create an OAuth application for Klaviyo
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Klaviyo integration to your server configuration. The integration automatically reads `KLAVIYO_CLIENT_ID` and `KLAVIYO_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, klaviyoIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
klaviyoIntegration({
scopes: ["accounts:read", "profiles:read", "profiles:write", "lists:read", "lists:write", "campaigns:read", "campaigns:write", "metrics:read"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
klaviyoIntegration({
clientId: process.env.CUSTOM_KLAVIYO_ID,
clientSecret: process.env.CUSTOM_KLAVIYO_SECRET,
scopes: ["accounts:read", "profiles:read", "profiles:write", "lists:read", "lists:write", "campaigns:read", "campaigns:write", "metrics:read"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("klaviyo");
const result = await client.klaviyo.listAccounts({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, klaviyoIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [klaviyoIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `accounts:read`
* `profiles:read`
* `profiles:write`
* `lists:read`
* `lists:write`
* `campaigns:read`
* `campaigns:write`
* `metrics:read`
Tools [#tools]
klaviyo_list_accounts [#klaviyo_list_accounts]
List accounts
klaviyo_list_profiles [#klaviyo_list_profiles]
List profiles
klaviyo_get_profile [#klaviyo_get_profile]
Get profile
klaviyo_create_profile [#klaviyo_create_profile]
Create profile
klaviyo_list_lists [#klaviyo_list_lists]
List lists
klaviyo_list_campaigns [#klaviyo_list_campaigns]
List campaigns
klaviyo_create_campaign [#klaviyo_create_campaign]
Create campaign
klaviyo_list_metrics [#klaviyo_list_metrics]
List metrics
Notes [#notes]
* Category: Marketing
* Authentication mode: OAuth
# Lever Integration
The Lever integration provides access to manage Lever list opportunities, get opportunity, create opportunity, list postings, list users through the Integrate MCP server.
Installation [#installation]
The Lever integration is included with the SDK:
```typescript
import { leverIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Lever OAuth App [#1-create-a-lever-oauth-app]
1. Create an OAuth application for Lever
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Lever integration to your server configuration. The integration automatically reads `LEVER_CLIENT_ID` and `LEVER_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, leverIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
leverIntegration({
scopes: ["opportunities:read", "opportunities:write", "postings:read", "postings:write", "users:read", "offline_access"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
leverIntegration({
clientId: process.env.CUSTOM_LEVER_ID,
clientSecret: process.env.CUSTOM_LEVER_SECRET,
scopes: ["opportunities:read", "opportunities:write", "postings:read", "postings:write", "users:read", "offline_access"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("lever");
const result = await client.lever.listOpportunities({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, leverIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [leverIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `opportunities:read`
* `opportunities:write`
* `postings:read`
* `postings:write`
* `users:read`
* `offline_access`
Tools [#tools]
lever_list_opportunities [#lever_list_opportunities]
List opportunities
lever_get_opportunity [#lever_get_opportunity]
Get opportunity
lever_create_opportunity [#lever_create_opportunity]
Create opportunity
lever_list_postings [#lever_list_postings]
List postings
lever_list_users [#lever_list_users]
List users
lever_list_stages [#lever_list_stages]
List stages
*No parameters.*
Notes [#notes]
* Category: HR & Recruiting
* Authentication mode: OAuth
# Linear Integration
The Linear integration provides access to manage Linear issues, projects, and cycles through the Integrate MCP server.
Installation [#installation]
The Linear integration is included with the SDK:
```typescript
import { linearIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Linear OAuth App [#1-create-a-linear-oauth-app]
1. Go to [Linear Settings](https://linear.app/settings/api)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Linear integration to your server configuration. The integration automatically reads `LINEAR_CLIENT_ID` and `LINEAR_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, linearIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
linearIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
linearIntegration({
clientId: process.env.CUSTOM_LINEAR_ID,
clientSecret: process.env.CUSTOM_LINEAR_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("linear");
const result = await client.linear.createIssue({
teamId: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, linearIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [linearIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
linear_create_issue [#linear_create_issue]
Create a new issue in Linear
linear_list_issues [#linear_list_issues]
List issues in Linear
linear_get_issue [#linear_get_issue]
Get a specific issue by ID or identifier
linear_update_issue [#linear_update_issue]
Update an existing issue
linear_archive_issue [#linear_archive_issue]
Archive an issue
linear_delete_issue [#linear_delete_issue]
Delete an issue permanently
linear_search_issues [#linear_search_issues]
Search for issues
linear_add_comment [#linear_add_comment]
Add a comment to an issue
linear_list_users [#linear_list_users]
List users in the workspace
linear_get_user [#linear_get_user]
Get a specific user by ID
linear_list_teams [#linear_list_teams]
List teams in Linear
linear_list_workflow_states [#linear_list_workflow_states]
List workflow states
linear_create_workflow_state [#linear_create_workflow_state]
Create a new workflow state
linear_list_projects [#linear_list_projects]
List projects in Linear
linear_get_project [#linear_get_project]
Get a specific project by ID
linear_create_project [#linear_create_project]
Create a new project
linear_update_project [#linear_update_project]
Update an existing project
linear_list_cycles [#linear_list_cycles]
List cycles (sprints)
linear_get_cycle [#linear_get_cycle]
Get a specific cycle by ID
linear_create_cycle [#linear_create_cycle]
Create a new cycle (sprint)
linear_update_cycle [#linear_update_cycle]
Update an existing cycle
linear_list_labels [#linear_list_labels]
List labels in Linear
linear_create_issue_relation [#linear_create_issue_relation]
Create a relation between two issues
linear_delete_issue_relation [#linear_delete_issue_relation]
Delete an issue relation
linear_list_documents [#linear_list_documents]
List documents
linear_get_document [#linear_get_document]
Get a specific document by ID
linear_create_document [#linear_create_document]
Create a new document
linear_update_document [#linear_update_document]
Update an existing document
linear_list_initiatives [#linear_list_initiatives]
List initiatives
linear_get_initiative [#linear_get_initiative]
Get a specific initiative by ID
linear_create_initiative [#linear_create_initiative]
Create a new initiative
linear_create_attachment [#linear_create_attachment]
Create an attachment (link) on an issue
linear_create_project_update [#linear_create_project_update]
Create a status update for a project
Notes [#notes]
* Category: Engineering
* Authentication mode: OAuth
# LinkedIn Integration
The LinkedIn integration provides access to read LinkedIn OpenID profile data and publish member posts through the Integrate MCP server.
Installation [#installation]
The LinkedIn integration is included with the SDK:
```typescript
import { linkedinIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a LinkedIn OAuth App [#1-create-a-linkedin-oauth-app]
1. Go to [Linkedin Developer Portal](https://www.linkedin.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the LinkedIn integration to your server configuration. The integration automatically reads `LINKEDIN_CLIENT_ID` and `LINKEDIN_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, linkedinIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
linkedinIntegration({
scopes: ["openid", "profile", "email", "w_member_social"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
linkedinIntegration({
clientId: process.env.CUSTOM_LINKEDIN_ID,
clientSecret: process.env.CUSTOM_LINKEDIN_SECRET,
scopes: ["openid", "profile", "email", "w_member_social"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("linkedin");
const result = await client.linkedin.getUserinfo({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, linkedinIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [linkedinIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `openid`
* `profile`
* `email`
* `w_member_social`
Tools [#tools]
linkedin_get_userinfo [#linkedin_get_userinfo]
Get userinfo
*No parameters.*
linkedin_create_post [#linkedin_create_post]
Create post
Notes [#notes]
* Category: Social Media
* Authentication mode: OAuth
# Looker Integration
The Looker integration provides access to manage Looker me, search dashboards, get dashboard, run query, list looks through the Integrate MCP server.
Installation [#installation]
The Looker integration is included with the SDK:
```typescript
import { lookerIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Looker OAuth App [#1-create-a-looker-oauth-app]
1. Create an OAuth application for Looker
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Looker integration to your server configuration. The integration automatically reads `LOOKER_CLIENT_ID` and `LOOKER_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, lookerIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
lookerIntegration({
scopes: ["read", "write"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
lookerIntegration({
clientId: process.env.CUSTOM_LOOKER_ID,
clientSecret: process.env.CUSTOM_LOOKER_SECRET,
scopes: ["read", "write"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("looker");
const result = await client.looker.me({
looker_base_url: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, lookerIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [lookerIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `read`
* `write`
Tools [#tools]
looker_me [#looker_me]
Me
looker_search_dashboards [#looker_search_dashboards]
Search dashboards
looker_get_dashboard [#looker_get_dashboard]
Get dashboard
looker_run_query [#looker_run_query]
Run query
looker_list_looks [#looker_list_looks]
List looks
looker_get_look [#looker_get_look]
Get look
Notes [#notes]
* Category: Data & BI
* Authentication mode: OAuth
# Mailchimp Integration
The Mailchimp integration provides access to manage Mailchimp audiences, members, and campaigns through the Integrate MCP server.
Installation [#installation]
The Mailchimp integration is included with the SDK:
```typescript
import { mailchimpIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Mailchimp OAuth App [#1-create-a-mailchimp-oauth-app]
1. Create an OAuth application for Mailchimp
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Mailchimp integration to your server configuration. The integration automatically reads `MAILCHIMP_CLIENT_ID` and `MAILCHIMP_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, mailchimpIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
mailchimpIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
mailchimpIntegration({
clientId: process.env.CUSTOM_MAILCHIMP_ID,
clientSecret: process.env.CUSTOM_MAILCHIMP_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("mailchimp");
// Use client.mailchimp methods after connecting
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, mailchimpIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [mailchimpIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
mailchimp_ping [#mailchimp_ping]
Ping
*No parameters.*
mailchimp_list_audiences [#mailchimp_list_audiences]
List audiences
*No parameters.*
mailchimp_get_audience [#mailchimp_get_audience]
Get audience
*No parameters.*
mailchimp_list_members [#mailchimp_list_members]
List members
*No parameters.*
mailchimp_get_member [#mailchimp_get_member]
Get member
*No parameters.*
mailchimp_add_or_update_member [#mailchimp_add_or_update_member]
Add or update member
*No parameters.*
mailchimp_archive_member [#mailchimp_archive_member]
Archive member
*No parameters.*
mailchimp_list_campaigns [#mailchimp_list_campaigns]
List campaigns
*No parameters.*
Notes [#notes]
* Category: Marketing
* Authentication mode: OAuth
# MapMyFitness Integration
The MapMyFitness integration provides access to manage MapMyFitness get user, list workouts, get workout, create workout, list routes through the Integrate MCP server.
Installation [#installation]
The MapMyFitness integration is included with the SDK:
```typescript
import { mapmyfitnessIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a MapMyFitness OAuth App [#1-create-a-mapmyfitness-oauth-app]
1. Create an OAuth application for MapMyFitness
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the MapMyFitness integration to your server configuration. The integration automatically reads `MAPMYFITNESS_CLIENT_ID` and `MAPMYFITNESS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, mapmyfitnessIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
mapmyfitnessIntegration({
scopes: ["read", "write"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
mapmyfitnessIntegration({
clientId: process.env.CUSTOM_MAPMYFITNESS_ID,
clientSecret: process.env.CUSTOM_MAPMYFITNESS_SECRET,
scopes: ["read", "write"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("mapmyfitness");
const result = await client.mapmyfitness.getUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, mapmyfitnessIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [mapmyfitnessIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `read`
* `write`
Tools [#tools]
mapmyfitness_get_user [#mapmyfitness_get_user]
Get user
*No parameters.*
mapmyfitness_list_workouts [#mapmyfitness_list_workouts]
List workouts
mapmyfitness_get_workout [#mapmyfitness_get_workout]
Get workout
mapmyfitness_create_workout [#mapmyfitness_create_workout]
Create workout
mapmyfitness_list_routes [#mapmyfitness_list_routes]
List routes
Notes [#notes]
* Category: Fitness
* Authentication mode: OAuth
# Meetup Integration
The Meetup integration provides access to manage Meetup get self, search groups, list events, get event, create event through the Integrate MCP server.
Installation [#installation]
The Meetup integration is included with the SDK:
```typescript
import { meetupIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Meetup OAuth App [#1-create-a-meetup-oauth-app]
1. Create an OAuth application for Meetup
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Meetup integration to your server configuration. The integration automatically reads `MEETUP_CLIENT_ID` and `MEETUP_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, meetupIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
meetupIntegration({
scopes: ["basic", "event_management", "group_edit", "rsvp"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
meetupIntegration({
clientId: process.env.CUSTOM_MEETUP_ID,
clientSecret: process.env.CUSTOM_MEETUP_SECRET,
scopes: ["basic", "event_management", "group_edit", "rsvp"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("meetup");
const result = await client.meetup.getSelf({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, meetupIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [meetupIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `basic`
* `event_management`
* `group_edit`
* `rsvp`
Tools [#tools]
meetup_get_self [#meetup_get_self]
Get self
*No parameters.*
meetup_search_groups [#meetup_search_groups]
Search groups
meetup_list_events [#meetup_list_events]
List events
meetup_get_event [#meetup_get_event]
Get event
meetup_create_event [#meetup_create_event]
Create event
meetup_rsvp_event [#meetup_rsvp_event]
Rsvp event
Notes [#notes]
* Category: Events & Ticketing
* Authentication mode: OAuth
# Mercury Integration
The Mercury integration provides access to manage Mercury bank accounts, cards, and transactions through the Integrate MCP server.
Installation [#installation]
The Mercury integration is included with the SDK:
```typescript
import { mercuryIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Mercury to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, mercuryIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
mercuryIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
// Use client.mercury methods after connecting
```
Environment Variables [#environment-variables]
* `MERCURY_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
mercury_get_organization [#mercury_get_organization]
Get organization
*No parameters.*
mercury_list_accounts [#mercury_list_accounts]
List accounts
*No parameters.*
mercury_get_account [#mercury_get_account]
Get account
*No parameters.*
mercury_get_account_cards [#mercury_get_account_cards]
Get account cards
*No parameters.*
mercury_list_account_transactions [#mercury_list_account_transactions]
List account transactions
*No parameters.*
mercury_get_account_transaction [#mercury_get_account_transaction]
Get account transaction
*No parameters.*
mercury_list_account_statements [#mercury_list_account_statements]
List account statements
*No parameters.*
mercury_download_statement_pdf [#mercury_download_statement_pdf]
Download statement pdf
*No parameters.*
mercury_list_transactions [#mercury_list_transactions]
List transactions
*No parameters.*
mercury_get_transaction [#mercury_get_transaction]
Get transaction
*No parameters.*
mercury_update_transaction [#mercury_update_transaction]
Update transaction
*No parameters.*
mercury_upload_transaction_attachment [#mercury_upload_transaction_attachment]
Upload transaction attachment
*No parameters.*
mercury_list_cards [#mercury_list_cards]
List cards
*No parameters.*
mercury_get_card [#mercury_get_card]
Get card
*No parameters.*
mercury_create_card [#mercury_create_card]
Create card
*No parameters.*
mercury_update_card [#mercury_update_card]
Update card
*No parameters.*
mercury_freeze_card [#mercury_freeze_card]
Freeze card
*No parameters.*
mercury_unfreeze_card [#mercury_unfreeze_card]
Unfreeze card
*No parameters.*
mercury_cancel_card [#mercury_cancel_card]
Cancel card
*No parameters.*
mercury_list_categories [#mercury_list_categories]
List categories
*No parameters.*
mercury_create_category [#mercury_create_category]
Create category
*No parameters.*
mercury_update_category [#mercury_update_category]
Update category
*No parameters.*
mercury_list_credit_accounts [#mercury_list_credit_accounts]
List credit accounts
*No parameters.*
mercury_list_users [#mercury_list_users]
List users
*No parameters.*
mercury_get_user [#mercury_get_user]
Get user
*No parameters.*
mercury_list_recipients [#mercury_list_recipients]
List recipients
*No parameters.*
mercury_get_recipient [#mercury_get_recipient]
Get recipient
*No parameters.*
mercury_create_recipient [#mercury_create_recipient]
Create recipient
*No parameters.*
mercury_update_recipient [#mercury_update_recipient]
Update recipient
*No parameters.*
mercury_list_recipient_attachments [#mercury_list_recipient_attachments]
List recipient attachments
*No parameters.*
mercury_upload_recipient_attachment [#mercury_upload_recipient_attachment]
Upload recipient attachment
*No parameters.*
mercury_list_customers [#mercury_list_customers]
List customers
*No parameters.*
mercury_get_customer [#mercury_get_customer]
Get customer
*No parameters.*
mercury_create_customer [#mercury_create_customer]
Create customer
*No parameters.*
mercury_update_customer [#mercury_update_customer]
Update customer
*No parameters.*
mercury_delete_customer [#mercury_delete_customer]
Delete customer
*No parameters.*
mercury_list_invoices [#mercury_list_invoices]
List invoices
*No parameters.*
mercury_get_invoice [#mercury_get_invoice]
Get invoice
*No parameters.*
mercury_create_invoice [#mercury_create_invoice]
Create invoice
*No parameters.*
mercury_update_invoice [#mercury_update_invoice]
Update invoice
*No parameters.*
mercury_cancel_invoice [#mercury_cancel_invoice]
Cancel invoice
*No parameters.*
mercury_list_invoice_attachments [#mercury_list_invoice_attachments]
List invoice attachments
*No parameters.*
mercury_get_attachment [#mercury_get_attachment]
Get attachment
*No parameters.*
mercury_download_invoice_pdf [#mercury_download_invoice_pdf]
Download invoice pdf
*No parameters.*
mercury_list_treasury_accounts [#mercury_list_treasury_accounts]
List treasury accounts
*No parameters.*
mercury_list_treasury_transactions [#mercury_list_treasury_transactions]
List treasury transactions
*No parameters.*
mercury_list_treasury_statements [#mercury_list_treasury_statements]
List treasury statements
*No parameters.*
mercury_list_events [#mercury_list_events]
List events
*No parameters.*
mercury_get_event [#mercury_get_event]
Get event
*No parameters.*
mercury_list_send_money_requests [#mercury_list_send_money_requests]
List send money requests
*No parameters.*
mercury_get_send_money_request [#mercury_get_send_money_request]
Get send money request
*No parameters.*
mercury_list_safe_requests [#mercury_list_safe_requests]
List safe requests
*No parameters.*
mercury_get_safe_request [#mercury_get_safe_request]
Get safe request
*No parameters.*
mercury_download_safe_request_document [#mercury_download_safe_request_document]
Download safe request document
*No parameters.*
mercury_list_webhooks [#mercury_list_webhooks]
List webhooks
*No parameters.*
mercury_get_webhook [#mercury_get_webhook]
Get webhook
*No parameters.*
mercury_create_webhook [#mercury_create_webhook]
Create webhook
*No parameters.*
mercury_update_webhook [#mercury_update_webhook]
Update webhook
*No parameters.*
mercury_delete_webhook [#mercury_delete_webhook]
Delete webhook
*No parameters.*
mercury_verify_webhook [#mercury_verify_webhook]
Verify webhook
*No parameters.*
mercury_create_internal_transfer [#mercury_create_internal_transfer]
Create internal transfer
*No parameters.*
mercury_send_money [#mercury_send_money]
Send money
*No parameters.*
mercury_request_send_money [#mercury_request_send_money]
Request send money
*No parameters.*
Notes [#notes]
* Category: Finance
* Authentication mode: API key
# Meta Ads Integration
The Meta Ads integration provides access to manage Meta Ads list ad accounts, get ad account, list campaigns, create campaign, list adsets through the Integrate MCP server.
Installation [#installation]
The Meta Ads integration is included with the SDK:
```typescript
import { metaAdsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Meta Ads OAuth App [#1-create-a-meta-ads-oauth-app]
1. Create an OAuth application for Meta Ads
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Meta Ads integration to your server configuration. The integration automatically reads `META_ADS_CLIENT_ID` and `META_ADS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, metaAdsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
metaAdsIntegration({
scopes: ["ads_read", "ads_management", "business_management"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
metaAdsIntegration({
clientId: process.env.CUSTOM_META_ADS_ID,
clientSecret: process.env.CUSTOM_META_ADS_SECRET,
scopes: ["ads_read", "ads_management", "business_management"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("meta_ads");
const result = await client.meta_ads.listAdAccounts({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, metaAdsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [metaAdsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `ads_read`
* `ads_management`
* `business_management`
Tools [#tools]
meta_ads_list_ad_accounts [#meta_ads_list_ad_accounts]
Ads list ad accounts
meta_ads_get_ad_account [#meta_ads_get_ad_account]
Ads get ad account
meta_ads_list_campaigns [#meta_ads_list_campaigns]
Ads list campaigns
meta_ads_create_campaign [#meta_ads_create_campaign]
Ads create campaign
meta_ads_list_adsets [#meta_ads_list_adsets]
Ads list adsets
meta_ads_list_ads [#meta_ads_list_ads]
Ads list ads
Notes [#notes]
* Category: Marketing
* Authentication mode: OAuth
# Microsoft Ads Integration
The Microsoft Ads integration provides access to manage Microsoft Ads get user, search accounts, get campaigns, add campaigns, get ad groups through the Integrate MCP server.
Installation [#installation]
The Microsoft Ads integration is included with the SDK:
```typescript
import { microsoftAdsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Microsoft Ads OAuth App [#1-create-a-microsoft-ads-oauth-app]
1. Go to [Azure Portal β App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Microsoft Ads integration to your server configuration. The integration automatically reads `MICROSOFT_ADS_CLIENT_ID` and `MICROSOFT_ADS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, microsoftAdsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
microsoftAdsIntegration({
scopes: ["https://ads.microsoft.com/msads.manage", "offline_access"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
microsoftAdsIntegration({
clientId: process.env.CUSTOM_MICROSOFT_ADS_ID,
clientSecret: process.env.CUSTOM_MICROSOFT_ADS_SECRET,
scopes: ["https://ads.microsoft.com/msads.manage", "offline_access"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("microsoft_ads");
const result = await client.microsoft_ads.getUser({
query_json: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, microsoftAdsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [microsoftAdsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `https://ads.microsoft.com/msads.manage`
* `offline_access`
Tools [#tools]
microsoft_ads_get_user [#microsoft_ads_get_user]
Ads get user
microsoft_ads_search_accounts [#microsoft_ads_search_accounts]
Ads search accounts
microsoft_ads_get_campaigns [#microsoft_ads_get_campaigns]
Ads get campaigns
microsoft_ads_add_campaigns [#microsoft_ads_add_campaigns]
Ads add campaigns
microsoft_ads_get_ad_groups [#microsoft_ads_get_ad_groups]
Ads get ad groups
microsoft_ads_get_keywords [#microsoft_ads_get_keywords]
Ads get keywords
Notes [#notes]
* Category: Marketing
* Authentication mode: OAuth
# Microsoft Bookings Integration
The Microsoft Bookings integration provides access to manage Microsoft Bookings businesses, services, staff members, and appointments through the Integrate MCP server.
Installation [#installation]
The Microsoft Bookings integration is included with the SDK:
```typescript
import { microsoftBookingsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Microsoft Bookings OAuth App [#1-create-a-microsoft-bookings-oauth-app]
1. Go to [Azure Portal β App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Microsoft Bookings integration to your server configuration. The integration automatically reads `MICROSOFT_BOOKINGS_CLIENT_ID` and `MICROSOFT_BOOKINGS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, microsoftBookingsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
microsoftBookingsIntegration({
scopes: ["offline_access", "User.Read", "Bookings.ReadWrite.All"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
microsoftBookingsIntegration({
clientId: process.env.CUSTOM_MICROSOFT_BOOKINGS_ID,
clientSecret: process.env.CUSTOM_MICROSOFT_BOOKINGS_SECRET,
scopes: ["offline_access", "User.Read", "Bookings.ReadWrite.All"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("microsoft_bookings");
const result = await client.microsoft_bookings.listBusinesses({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, microsoftBookingsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [microsoftBookingsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `offline_access`
* `User.Read`
* `Bookings.ReadWrite.All`
Tools [#tools]
microsoft_bookings_list_businesses [#microsoft_bookings_list_businesses]
Bookings list businesses
microsoft_bookings_get_business [#microsoft_bookings_get_business]
Bookings get business
microsoft_bookings_list_services [#microsoft_bookings_list_services]
Bookings list services
microsoft_bookings_list_staff_members [#microsoft_bookings_list_staff_members]
Bookings list staff members
microsoft_bookings_list_appointments [#microsoft_bookings_list_appointments]
Bookings list appointments
microsoft_bookings_create_appointment [#microsoft_bookings_create_appointment]
Bookings create appointment
Notes [#notes]
* Category: Scheduling
* Authentication mode: OAuth
# Microsoft Entra ID Integration
The Microsoft Entra ID integration provides access to manage Microsoft Entra ID list users, get user, create user, list groups, list applications through the Integrate MCP server.
Installation [#installation]
The Microsoft Entra ID integration is included with the SDK:
```typescript
import { microsoftEntraIdIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Microsoft Entra ID OAuth App [#1-create-a-microsoft-entra-id-oauth-app]
1. Go to [Azure Portal β App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Microsoft Entra ID integration to your server configuration. The integration automatically reads `MICROSOFT_ENTRA_ID_CLIENT_ID` and `MICROSOFT_ENTRA_ID_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, microsoftEntraIdIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
microsoftEntraIdIntegration({
scopes: ["User.ReadWrite.All", "Group.ReadWrite.All", "Application.ReadWrite.All", "Directory.Read.All", "AuditLog.Read.All", "offline_access"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
microsoftEntraIdIntegration({
clientId: process.env.CUSTOM_MICROSOFT_ENTRA_ID_ID,
clientSecret: process.env.CUSTOM_MICROSOFT_ENTRA_ID_SECRET,
scopes: ["User.ReadWrite.All", "Group.ReadWrite.All", "Application.ReadWrite.All", "Directory.Read.All", "AuditLog.Read.All", "offline_access"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("microsoft_entra_id");
const result = await client.microsoft_entra_id.listUsers({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, microsoftEntraIdIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [microsoftEntraIdIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `User.ReadWrite.All`
* `Group.ReadWrite.All`
* `Application.ReadWrite.All`
* `Directory.Read.All`
* `AuditLog.Read.All`
* `offline_access`
Tools [#tools]
microsoft_entra_id_list_users [#microsoft_entra_id_list_users]
Entra id list users
microsoft_entra_id_get_user [#microsoft_entra_id_get_user]
Entra id get user
microsoft_entra_id_create_user [#microsoft_entra_id_create_user]
Entra id create user
microsoft_entra_id_list_groups [#microsoft_entra_id_list_groups]
Entra id list groups
microsoft_entra_id_list_applications [#microsoft_entra_id_list_applications]
Entra id list applications
microsoft_entra_id_list_audit_logs [#microsoft_entra_id_list_audit_logs]
Entra id list audit logs
Notes [#notes]
* Category: Identity & Access
* Authentication mode: OAuth
# Microsoft Graph Education Integration
The Microsoft Graph Education integration provides access to manage Microsoft Graph Education list classes, get class, list users, list assignments, create assignment through the Integrate MCP server.
Installation [#installation]
The Microsoft Graph Education integration is included with the SDK:
```typescript
import { microsoftGraphEducationIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Microsoft Graph Education OAuth App [#1-create-a-microsoft-graph-education-oauth-app]
1. Go to [Azure Portal β App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Microsoft Graph Education integration to your server configuration. The integration automatically reads `MICROSOFT_GRAPH_EDUCATION_CLIENT_ID` and `MICROSOFT_GRAPH_EDUCATION_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, microsoftGraphEducationIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
microsoftGraphEducationIntegration({
scopes: ["EduRoster.ReadWrite", "EduAssignments.ReadWrite", "offline_access"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
microsoftGraphEducationIntegration({
clientId: process.env.CUSTOM_MICROSOFT_GRAPH_EDUCATION_ID,
clientSecret: process.env.CUSTOM_MICROSOFT_GRAPH_EDUCATION_SECRET,
scopes: ["EduRoster.ReadWrite", "EduAssignments.ReadWrite", "offline_access"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("microsoft_graph_education");
const result = await client.microsoft_graph_education.listClasses({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, microsoftGraphEducationIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [microsoftGraphEducationIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `EduRoster.ReadWrite`
* `EduAssignments.ReadWrite`
* `offline_access`
Tools [#tools]
microsoft_graph_education_list_classes [#microsoft_graph_education_list_classes]
Graph education list classes
microsoft_graph_education_get_class [#microsoft_graph_education_get_class]
Graph education get class
microsoft_graph_education_list_users [#microsoft_graph_education_list_users]
Graph education list users
microsoft_graph_education_list_assignments [#microsoft_graph_education_list_assignments]
Graph education list assignments
microsoft_graph_education_create_assignment [#microsoft_graph_education_create_assignment]
Graph education create assignment
microsoft_graph_education_list_schools [#microsoft_graph_education_list_schools]
Graph education list schools
Notes [#notes]
* Category: Education
* Authentication mode: OAuth
# Microsoft To Do Integration
The Microsoft To Do integration provides access to manage Microsoft To Do task lists and tasks through Microsoft Graph through the Integrate MCP server.
Installation [#installation]
The Microsoft To Do integration is included with the SDK:
```typescript
import { microsoftToDoIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Microsoft To Do OAuth App [#1-create-a-microsoft-to-do-oauth-app]
1. Go to [Azure Portal β App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Microsoft To Do integration to your server configuration. The integration automatically reads `MICROSOFT_TO_DO_CLIENT_ID` and `MICROSOFT_TO_DO_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, microsoftToDoIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
microsoftToDoIntegration({
scopes: ["offline_access", "User.Read", "Tasks.ReadWrite"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
microsoftToDoIntegration({
clientId: process.env.CUSTOM_MICROSOFT_TO_DO_ID,
clientSecret: process.env.CUSTOM_MICROSOFT_TO_DO_SECRET,
scopes: ["offline_access", "User.Read", "Tasks.ReadWrite"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("microsoft_to_do");
const result = await client.microsoft_to_do.listTaskLists({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, microsoftToDoIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [microsoftToDoIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `offline_access`
* `User.Read`
* `Tasks.ReadWrite`
Tools [#tools]
microsoft_to_do_list_task_lists [#microsoft_to_do_list_task_lists]
To do list task lists
microsoft_to_do_get_task_list [#microsoft_to_do_get_task_list]
To do get task list
microsoft_to_do_create_task_list [#microsoft_to_do_create_task_list]
To do create task list
microsoft_to_do_list_tasks [#microsoft_to_do_list_tasks]
To do list tasks
microsoft_to_do_get_task [#microsoft_to_do_get_task]
To do get task
microsoft_to_do_create_task [#microsoft_to_do_create_task]
To do create task
microsoft_to_do_update_task [#microsoft_to_do_update_task]
To do update task
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Miele Integration
The Miele integration provides access to manage Miele list devices, get device, get actions, execute action, get programs through the Integrate MCP server.
Installation [#installation]
The Miele integration is included with the SDK:
```typescript
import { mieleIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Miele OAuth App [#1-create-a-miele-oauth-app]
1. Create an OAuth application for Miele
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Miele integration to your server configuration. The integration automatically reads `MIELE_CLIENT_ID` and `MIELE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, mieleIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
mieleIntegration({
scopes: ["openid", "offline_access", "read", "write"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
mieleIntegration({
clientId: process.env.CUSTOM_MIELE_ID,
clientSecret: process.env.CUSTOM_MIELE_SECRET,
scopes: ["openid", "offline_access", "read", "write"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("miele");
const result = await client.miele.listDevices({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, mieleIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [mieleIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `openid`
* `offline_access`
* `read`
* `write`
Tools [#tools]
miele_list_devices [#miele_list_devices]
List devices
miele_get_device [#miele_get_device]
Get device
miele_get_actions [#miele_get_actions]
Get actions
miele_execute_action [#miele_execute_action]
Execute action
miele_get_programs [#miele_get_programs]
Get programs
Notes [#notes]
* Category: Lifestyle
* Authentication mode: OAuth
# Miro Integration
The Miro integration provides access to manage Miro boards, board items, comments, members, and collaborators through the Integrate MCP server.
Installation [#installation]
The Miro integration is included with the SDK:
```typescript
import { miroIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Miro OAuth App [#1-create-a-miro-oauth-app]
1. Create an OAuth application for Miro
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Miro integration to your server configuration. The integration automatically reads `MIRO_CLIENT_ID` and `MIRO_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, miroIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
miroIntegration({
scopes: ["boards:read", "boards:write", "identity:read", "team:read"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
miroIntegration({
clientId: process.env.CUSTOM_MIRO_ID,
clientSecret: process.env.CUSTOM_MIRO_SECRET,
scopes: ["boards:read", "boards:write", "identity:read", "team:read"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("miro");
const result = await client.miro.getCurrentUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, miroIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [miroIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `boards:read`
* `boards:write`
* `identity:read`
* `team:read`
Tools [#tools]
miro_get_current_user [#miro_get_current_user]
Get current user
*No parameters.*
miro_list_boards [#miro_list_boards]
List boards
miro_get_board [#miro_get_board]
Get board
miro_create_board [#miro_create_board]
Create board
miro_list_board_items [#miro_list_board_items]
List board items
miro_create_board_item [#miro_create_board_item]
Create board item
miro_list_comments [#miro_list_comments]
List comments
miro_list_board_members [#miro_list_board_members]
List board members
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Monday.com Integration
The Monday.com integration provides access to manage Monday.com boards, items, columns, and updates through the Integrate MCP server.
Installation [#installation]
The Monday.com integration is included with the SDK:
```typescript
import { mondayIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Monday.com OAuth App [#1-create-a-mondaycom-oauth-app]
1. Go to [Auth Developer Portal](https://auth.monday.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Monday.com integration to your server configuration. The integration automatically reads `MONDAY_CLIENT_ID` and `MONDAY_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, mondayIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
mondayIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
mondayIntegration({
clientId: process.env.CUSTOM_MONDAY_ID,
clientSecret: process.env.CUSTOM_MONDAY_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("monday");
const result = await client.monday.me({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, mondayIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [mondayIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
monday_me [#monday_me]
Me
*No parameters.*
monday_list_workspaces [#monday_list_workspaces]
List workspaces
*No parameters.*
monday_list_boards [#monday_list_boards]
List boards
monday_get_board [#monday_get_board]
Get board
monday_list_board_items [#monday_list_board_items]
List board items
monday_next_items_page [#monday_next_items_page]
Next items page
monday_get_items [#monday_get_items]
Get items
monday_create_item [#monday_create_item]
Create item
monday_update_item_columns [#monday_update_item_columns]
Update item columns
monday_create_update [#monday_create_update]
Create update
monday_delete_item [#monday_delete_item]
Delete item
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Moneybird Integration
The Moneybird integration provides access to manage Moneybird list administrations, list contacts, create contact, list sales invoices, create sales invoice through the Integrate MCP server.
Installation [#installation]
The Moneybird integration is included with the SDK:
```typescript
import { moneybirdIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Moneybird OAuth App [#1-create-a-moneybird-oauth-app]
1. Create an OAuth application for Moneybird
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Moneybird integration to your server configuration. The integration automatically reads `MONEYBIRD_CLIENT_ID` and `MONEYBIRD_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, moneybirdIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
moneybirdIntegration({
scopes: ["sales_invoices", "documents", "estimates", "bank", "settings"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
moneybirdIntegration({
clientId: process.env.CUSTOM_MONEYBIRD_ID,
clientSecret: process.env.CUSTOM_MONEYBIRD_SECRET,
scopes: ["sales_invoices", "documents", "estimates", "bank", "settings"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("moneybird");
const result = await client.moneybird.listAdministrations({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, moneybirdIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [moneybirdIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `sales_invoices`
* `documents`
* `estimates`
* `bank`
* `settings`
Tools [#tools]
moneybird_list_administrations [#moneybird_list_administrations]
List administrations
*No parameters.*
moneybird_list_contacts [#moneybird_list_contacts]
List contacts
moneybird_create_contact [#moneybird_create_contact]
Create contact
moneybird_list_sales_invoices [#moneybird_list_sales_invoices]
List sales invoices
moneybird_create_sales_invoice [#moneybird_create_sales_invoice]
Create sales invoice
moneybird_list_financial_accounts [#moneybird_list_financial_accounts]
List financial accounts
Notes [#notes]
* Category: Accounting
* Authentication mode: OAuth
# Neon Integration
The Neon integration provides access to manage Neon Postgres projects, branches, API keys, and connection strings through the Integrate MCP server.
Installation [#installation]
The Neon integration is included with the SDK:
```typescript
import { neonIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Neon to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, neonIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
neonIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.neon.listApiKeys({});
console.log(result);
```
Environment Variables [#environment-variables]
* `NEON_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
neon_list_api_keys [#neon_list_api_keys]
List api keys
*No parameters.*
neon_create_api_key [#neon_create_api_key]
Create api key
neon_revoke_api_key [#neon_revoke_api_key]
Revoke api key
neon_list_organizations [#neon_list_organizations]
List organizations
*No parameters.*
neon_list_projects [#neon_list_projects]
List projects
neon_list_shared_projects [#neon_list_shared_projects]
List shared projects
neon_create_project [#neon_create_project]
Create project
neon_get_project [#neon_get_project]
Get project
neon_update_project [#neon_update_project]
Update project
neon_delete_project [#neon_delete_project]
Delete project
neon_recover_project [#neon_recover_project]
Recover project
neon_list_branches [#neon_list_branches]
List branches
neon_create_branch [#neon_create_branch]
Create branch
neon_get_branch [#neon_get_branch]
Get branch
neon_delete_branch [#neon_delete_branch]
Delete branch
neon_list_operations [#neon_list_operations]
List operations
neon_get_operation [#neon_get_operation]
Get operation
neon_get_connection_uri [#neon_get_connection_uri]
Get connection uri
Notes [#notes]
* Category: Infrastructure
* Authentication mode: API key
# Netatmo Integration
The Netatmo integration provides access to manage Netatmo get homesdata, get stationsdata, get measure, set thermpoint, get events through the Integrate MCP server.
Installation [#installation]
The Netatmo integration is included with the SDK:
```typescript
import { netatmoIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Netatmo OAuth App [#1-create-a-netatmo-oauth-app]
1. Create an OAuth application for Netatmo
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Netatmo integration to your server configuration. The integration automatically reads `NETATMO_CLIENT_ID` and `NETATMO_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, netatmoIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
netatmoIntegration({
scopes: ["read_station", "read_thermostat", "write_thermostat", "read_camera", "access_camera", "read_presence", "write_presence", "read_homecoach"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
netatmoIntegration({
clientId: process.env.CUSTOM_NETATMO_ID,
clientSecret: process.env.CUSTOM_NETATMO_SECRET,
scopes: ["read_station", "read_thermostat", "write_thermostat", "read_camera", "access_camera", "read_presence", "write_presence", "read_homecoach"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("netatmo");
const result = await client.netatmo.getHomesdata({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, netatmoIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [netatmoIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `read_station`
* `read_thermostat`
* `write_thermostat`
* `read_camera`
* `access_camera`
* `read_presence`
* `write_presence`
* `read_homecoach`
Tools [#tools]
netatmo_get_homesdata [#netatmo_get_homesdata]
Get homesdata
netatmo_get_stationsdata [#netatmo_get_stationsdata]
Get stationsdata
netatmo_get_measure [#netatmo_get_measure]
Get measure
netatmo_set_thermpoint [#netatmo_set_thermpoint]
Set thermpoint
netatmo_get_events [#netatmo_get_events]
Get events
Notes [#notes]
* Category: Lifestyle
* Authentication mode: OAuth
# Netlify Integration
The Netlify integration provides access to manage Netlify sites, deploys, builds, and environment variables through the Integrate MCP server.
Installation [#installation]
The Netlify integration is included with the SDK:
```typescript
import { netlifyIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Netlify OAuth App [#1-create-a-netlify-oauth-app]
1. Go to [App Developer Portal](https://app.netlify.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Netlify integration to your server configuration. The integration automatically reads `NETLIFY_CLIENT_ID` and `NETLIFY_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, netlifyIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
netlifyIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
netlifyIntegration({
clientId: process.env.CUSTOM_NETLIFY_ID,
clientSecret: process.env.CUSTOM_NETLIFY_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("netlify");
const result = await client.netlify.getCurrentUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, netlifyIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [netlifyIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
netlify_get_current_user [#netlify_get_current_user]
Get current user
*No parameters.*
netlify_list_accounts [#netlify_list_accounts]
List accounts
*No parameters.*
netlify_get_account [#netlify_get_account]
Get account
netlify_list_sites [#netlify_list_sites]
List sites
netlify_get_site [#netlify_get_site]
Get site
netlify_create_site [#netlify_create_site]
Create site
netlify_update_site [#netlify_update_site]
Update site
netlify_delete_site [#netlify_delete_site]
Delete site
netlify_enable_site [#netlify_enable_site]
Enable site
netlify_disable_site [#netlify_disable_site]
Disable site
netlify_list_deploys [#netlify_list_deploys]
List deploys
netlify_get_deploy [#netlify_get_deploy]
Get deploy
netlify_create_deploy [#netlify_create_deploy]
Create deploy
netlify_cancel_deploy [#netlify_cancel_deploy]
Cancel deploy
netlify_restore_deploy [#netlify_restore_deploy]
Restore deploy
netlify_lock_deploy [#netlify_lock_deploy]
Lock deploy
netlify_unlock_deploy [#netlify_unlock_deploy]
Unlock deploy
netlify_list_builds [#netlify_list_builds]
List builds
netlify_get_build [#netlify_get_build]
Get build
netlify_trigger_build [#netlify_trigger_build]
Trigger build
netlify_list_env_vars [#netlify_list_env_vars]
List env vars
netlify_get_env_var [#netlify_get_env_var]
Get env var
netlify_create_env_vars [#netlify_create_env_vars]
Create env vars
netlify_update_env_var [#netlify_update_env_var]
Update env var
netlify_delete_env_var [#netlify_delete_env_var]
Delete env var
netlify_list_build_hooks [#netlify_list_build_hooks]
List build hooks
netlify_create_build_hook [#netlify_create_build_hook]
Create build hook
netlify_delete_build_hook [#netlify_delete_build_hook]
Delete build hook
netlify_list_forms [#netlify_list_forms]
List forms
netlify_list_form_submissions [#netlify_list_form_submissions]
List form submissions
netlify_list_dns_zones [#netlify_list_dns_zones]
List dns zones
*No parameters.*
netlify_get_dns_records [#netlify_get_dns_records]
Get dns records
netlify_create_dns_record [#netlify_create_dns_record]
Create dns record
netlify_delete_dns_record [#netlify_delete_dns_record]
Delete dns record
netlify_list_functions [#netlify_list_functions]
List functions
netlify_list_files [#netlify_list_files]
List files
netlify_purge_cache [#netlify_purge_cache]
Purge cache
Notes [#notes]
* Category: Infrastructure
* Authentication mode: OAuth
# Notion Integration
The Notion integration provides access to manage Notion pages and databases through the Integrate MCP server.
Installation [#installation]
The Notion integration is included with the SDK:
```typescript
import { notionIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Notion OAuth App [#1-create-a-notion-oauth-app]
1. Go to [Notion Integrations](https://www.notion.so/my-integrations)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Notion integration to your server configuration. The integration automatically reads `NOTION_CLIENT_ID` and `NOTION_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, notionIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
notionIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
notionIntegration({
clientId: process.env.CUSTOM_NOTION_ID,
clientSecret: process.env.CUSTOM_NOTION_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("notion");
const result = await client.notion.search({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, notionIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [notionIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
notion_search [#notion_search]
Search for pages and databases in Notion
notion_get_page [#notion_get_page]
Retrieve a Notion page by ID
notion_create_page [#notion_create_page]
Create a new page under a page or database parent
notion_update_page [#notion_update_page]
Update a page's properties, icon, cover, or archive status
notion_get_page_property [#notion_get_page_property]
Get a specific property value from a page with pagination support
notion_get_database [#notion_get_database]
Get a database by ID including its schema
notion_query_database [#notion_query_database]
Query a database with filters, sorts, and pagination
notion_create_database [#notion_create_database]
Create a new database under a parent page
notion_update_database [#notion_update_database]
Update a database's title, description, properties, or archive status
notion_get_block [#notion_get_block]
Get a block by ID
notion_get_block_children [#notion_get_block_children]
Get child blocks of a block with pagination
notion_append_blocks [#notion_append_blocks]
Append child blocks to a parent block
notion_update_block [#notion_update_block]
Update a block's content
notion_delete_block [#notion_delete_block]
Delete (archive) a block
notion_get_user [#notion_get_user]
Get a user by ID
notion_get_current_user [#notion_get_current_user]
Get the bot user associated with the current token
*No parameters.*
notion_list_users [#notion_list_users]
List workspace users with pagination
notion_create_comment [#notion_create_comment]
Create a comment on a page or reply to a discussion
notion_list_comments [#notion_list_comments]
List comments on a block or page
notion_move_page [#notion_move_page]
Move a page to a new parent page or data source
notion_create_file_upload [#notion_create_file_upload]
Create a Notion file upload. Use mode "external\_url" to import from a URL,
notion_send_file_upload [#notion_send_file_upload]
Send file content for a Notion file upload (single\_part mode).
notion_complete_file_upload [#notion_complete_file_upload]
Complete a Notion file upload after sending content
notion_get_file_upload [#notion_get_file_upload]
Get the status of a Notion file upload
notion_create_data_source [#notion_create_data_source]
Create a new Notion data source under a parent page
notion_get_data_source [#notion_get_data_source]
Get a Notion data source by its ID
notion_update_data_source [#notion_update_data_source]
Update a Notion data source's title, description, properties, or status
notion_query_data_source [#notion_query_data_source]
Query a Notion data source with optional filters, sorts, and pagination
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Okta Integration
The Okta integration provides access to manage Okta users, groups, apps, authorization servers, policies, and system logs through the Integrate MCP server.
Installation [#installation]
The Okta integration is included with the SDK:
```typescript
import { oktaIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Okta OAuth App [#1-create-an-okta-oauth-app]
1. Create an OAuth application for Okta
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Okta integration to your server configuration. The integration automatically reads `OKTA_CLIENT_ID` and `OKTA_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, oktaIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
oktaIntegration({
scopes: ["openid", "profile", "email", "offline_access", "okta.users.read", "okta.users.manage", "okta.groups.read", "okta.groups.manage", "okta.apps.read", "okta.logs.read"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
oktaIntegration({
clientId: process.env.CUSTOM_OKTA_ID,
clientSecret: process.env.CUSTOM_OKTA_SECRET,
scopes: ["openid", "profile", "email", "offline_access", "okta.users.read", "okta.users.manage", "okta.groups.read", "okta.groups.manage", "okta.apps.read", "okta.logs.read"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("okta");
const result = await client.okta.listUsers({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, oktaIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [oktaIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `openid`
* `profile`
* `email`
* `offline_access`
* `okta.users.read`
* `okta.users.manage`
* `okta.groups.read`
* `okta.groups.manage`
* `okta.apps.read`
* `okta.logs.read`
Tools [#tools]
okta_list_users [#okta_list_users]
List users
okta_get_user [#okta_get_user]
Get user
okta_create_user [#okta_create_user]
Create user
okta_update_user [#okta_update_user]
Update user
okta_deactivate_user [#okta_deactivate_user]
Deactivate user
okta_list_groups [#okta_list_groups]
List groups
okta_get_group [#okta_get_group]
Get group
okta_create_group [#okta_create_group]
Create group
okta_add_user_to_group [#okta_add_user_to_group]
Add user to group
okta_remove_user_from_group [#okta_remove_user_from_group]
Remove user from group
okta_list_apps [#okta_list_apps]
List apps
okta_get_app [#okta_get_app]
Get app
okta_list_authorization_servers [#okta_list_authorization_servers]
List authorization servers
okta_list_policies [#okta_list_policies]
List policies
okta_list_system_logs [#okta_list_system_logs]
List system logs
Notes [#notes]
* Category: Identity & Access
* Authentication mode: OAuth
# OneDrive Integration
The OneDrive integration provides access to manage OneDrive files, folders, and sharing through the Integrate MCP server.
Installation [#installation]
The OneDrive integration is included with the SDK:
```typescript
import { onedriveIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an OneDrive OAuth App [#1-create-an-onedrive-oauth-app]
1. Go to [Azure Portal β App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the OneDrive integration to your server configuration. The integration automatically reads `ONEDRIVE_CLIENT_ID` and `ONEDRIVE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, onedriveIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
onedriveIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
onedriveIntegration({
clientId: process.env.CUSTOM_ONEDRIVE_ID,
clientSecret: process.env.CUSTOM_ONEDRIVE_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("onedrive");
const result = await client.onedrive.listFiles({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, onedriveIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [onedriveIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
onedrive_create_folder [#onedrive_create_folder]
Create folder
onedrive_delete_file [#onedrive_delete_file]
Delete a file or folder permanently
onedrive_download_file [#onedrive_download_file]
Get the download URL for a file
onedrive_get_file [#onedrive_get_file]
Get metadata for a file or folder
onedrive_list_files [#onedrive_list_files]
List files and folders in OneDrive
onedrive_list_permissions [#onedrive_list_permissions]
List permissions
onedrive_remove_permission [#onedrive_remove_permission]
Remove permission
onedrive_search_files [#onedrive_search_files]
Search across all files in OneDrive
onedrive_share_file [#onedrive_share_file]
Create a sharing link for a file or folder
onedrive_upload_file [#onedrive_upload_file]
Upload a file to OneDrive
Notes [#notes]
* Category: Storage
* Authentication mode: OAuth
# OneLogin Integration
The OneLogin integration provides access to manage OneLogin list users, get user, create user, list roles, list apps through the Integrate MCP server.
Installation [#installation]
The OneLogin integration is included with the SDK:
```typescript
import { oneloginIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an OneLogin OAuth App [#1-create-an-onelogin-oauth-app]
1. Create an OAuth application for OneLogin
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the OneLogin integration to your server configuration. The integration automatically reads `ONELOGIN_CLIENT_ID` and `ONELOGIN_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, oneloginIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
oneloginIntegration({
scopes: ["openid", "profile", "manage:all"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
oneloginIntegration({
clientId: process.env.CUSTOM_ONELOGIN_ID,
clientSecret: process.env.CUSTOM_ONELOGIN_SECRET,
scopes: ["openid", "profile", "manage:all"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("onelogin");
const result = await client.onelogin.listUsers({
region: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, oneloginIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [oneloginIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `openid`
* `profile`
* `manage:all`
Tools [#tools]
onelogin_list_users [#onelogin_list_users]
List users
onelogin_get_user [#onelogin_get_user]
Get user
onelogin_create_user [#onelogin_create_user]
Create user
onelogin_list_roles [#onelogin_list_roles]
List roles
onelogin_list_apps [#onelogin_list_apps]
List apps
onelogin_list_events [#onelogin_list_events]
List events
Notes [#notes]
* Category: Identity & Access
* Authentication mode: OAuth
# OneNote Integration
The OneNote integration provides access to manage OneNote notebooks, sections, pages, and section creation through Microsoft Graph through the Integrate MCP server.
Installation [#installation]
The OneNote integration is included with the SDK:
```typescript
import { onenoteIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an OneNote OAuth App [#1-create-an-onenote-oauth-app]
1. Go to [Azure Portal β App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the OneNote integration to your server configuration. The integration automatically reads `ONENOTE_CLIENT_ID` and `ONENOTE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, onenoteIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
onenoteIntegration({
scopes: ["offline_access", "User.Read", "Notes.ReadWrite.All"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
onenoteIntegration({
clientId: process.env.CUSTOM_ONENOTE_ID,
clientSecret: process.env.CUSTOM_ONENOTE_SECRET,
scopes: ["offline_access", "User.Read", "Notes.ReadWrite.All"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("onenote");
const result = await client.onenote.listNotebooks({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, onenoteIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [onenoteIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `offline_access`
* `User.Read`
* `Notes.ReadWrite.All`
Tools [#tools]
onenote_list_notebooks [#onenote_list_notebooks]
List notebooks
onenote_get_notebook [#onenote_get_notebook]
Get notebook
onenote_list_sections [#onenote_list_sections]
List sections
onenote_create_section [#onenote_create_section]
Create section
onenote_list_pages [#onenote_list_pages]
List pages
onenote_get_page [#onenote_get_page]
Get page
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Oura Integration
The Oura integration provides access to manage Oura get personal info, list daily activity, list sleep, list workouts, list sessions through the Integrate MCP server.
Installation [#installation]
The Oura integration is included with the SDK:
```typescript
import { ouraIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Oura OAuth App [#1-create-an-oura-oauth-app]
1. Create an OAuth application for Oura
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Oura integration to your server configuration. The integration automatically reads `OURA_CLIENT_ID` and `OURA_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, ouraIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
ouraIntegration({
scopes: ["email", "personal", "daily", "heartrate", "workout", "session", "tag"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
ouraIntegration({
clientId: process.env.CUSTOM_OURA_ID,
clientSecret: process.env.CUSTOM_OURA_SECRET,
scopes: ["email", "personal", "daily", "heartrate", "workout", "session", "tag"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("oura");
const result = await client.oura.getPersonalInfo({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, ouraIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [ouraIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `email`
* `personal`
* `daily`
* `heartrate`
* `workout`
* `session`
* `tag`
Tools [#tools]
oura_get_personal_info [#oura_get_personal_info]
Get personal info
*No parameters.*
oura_list_daily_activity [#oura_list_daily_activity]
List daily activity
oura_list_sleep [#oura_list_sleep]
List sleep
oura_list_workouts [#oura_list_workouts]
List workouts
oura_list_sessions [#oura_list_sessions]
List sessions
oura_list_tags [#oura_list_tags]
List tags
Notes [#notes]
* Category: Fitness
* Authentication mode: OAuth
# Outlook Integration
The Outlook integration provides access to manage Outlook mail, calendars, and contacts through the Integrate MCP server.
Installation [#installation]
The Outlook integration is included with the SDK:
```typescript
import { outlookIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Outlook OAuth App [#1-create-an-outlook-oauth-app]
1. Go to [Azure Portal β App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Outlook integration to your server configuration. The integration automatically reads `OUTLOOK_CLIENT_ID` and `OUTLOOK_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, outlookIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
outlookIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
outlookIntegration({
clientId: process.env.CUSTOM_OUTLOOK_ID,
clientSecret: process.env.CUSTOM_OUTLOOK_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("outlook");
const result = await client.outlook.listMessages({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, outlookIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [outlookIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
outlook_accept_event [#outlook_accept_event]
Accept a calendar event invitation
outlook_create_draft [#outlook_create_draft]
Create a draft message (not sent)
outlook_create_event [#outlook_create_event]
Create a new calendar event
outlook_decline_event [#outlook_decline_event]
Decline a calendar event invitation
outlook_delete_event [#outlook_delete_event]
Delete a calendar event
outlook_delete_message [#outlook_delete_message]
Delete a message permanently
outlook_find_meeting_times [#outlook_find_meeting_times]
Find available meeting times for a set of attendees
outlook_forward_message [#outlook_forward_message]
Forward a message to one or more recipients
outlook_get_contact [#outlook_get_contact]
Get a specific contact by ID
outlook_get_event [#outlook_get_event]
Get a specific calendar event by ID
outlook_get_message [#outlook_get_message]
Get a specific message by ID
outlook_get_schedule [#outlook_get_schedule]
Get free/busy schedule for a set of users or resources
outlook_list_calendars [#outlook_list_calendars]
List all calendars for the authenticated user
*No parameters.*
outlook_list_contacts [#outlook_list_contacts]
List contacts in the address book
outlook_list_events [#outlook_list_events]
List calendar events
outlook_list_mail_folders [#outlook_list_mail_folders]
List mail folders in the mailbox
outlook_list_messages [#outlook_list_messages]
List messages in the mailbox
outlook_mark_message_read [#outlook_mark_message_read]
Mark a message as read or unread
outlook_move_message [#outlook_move_message]
Move a message to another folder
outlook_reply_all_message [#outlook_reply_all_message]
Reply all to a message
outlook_reply_message [#outlook_reply_message]
Reply to a message
outlook_search_messages [#outlook_search_messages]
Search messages by keyword query
outlook_send_message [#outlook_send_message]
Send a new email message
outlook_tentatively_accept_event [#outlook_tentatively_accept_event]
Tentatively accept a calendar event invitation
outlook_update_event [#outlook_update_event]
Update an existing calendar event
Notes [#notes]
* Category: Communication
* Authentication mode: OAuth
# PandaDoc Integration
The PandaDoc integration provides access to manage PandaDoc list documents, get document, create document, send document, list templates through the Integrate MCP server.
Installation [#installation]
The PandaDoc integration is included with the SDK:
```typescript
import { pandadocIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a PandaDoc OAuth App [#1-create-a-pandadoc-oauth-app]
1. Create an OAuth application for PandaDoc
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the PandaDoc integration to your server configuration. The integration automatically reads `PANDADOC_CLIENT_ID` and `PANDADOC_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, pandadocIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
pandadocIntegration({
scopes: ["read+write"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
pandadocIntegration({
clientId: process.env.CUSTOM_PANDADOC_ID,
clientSecret: process.env.CUSTOM_PANDADOC_SECRET,
scopes: ["read+write"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("pandadoc");
const result = await client.pandadoc.listDocuments({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, pandadocIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [pandadocIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `read+write`
Tools [#tools]
pandadoc_list_documents [#pandadoc_list_documents]
List documents
pandadoc_get_document [#pandadoc_get_document]
Get document
pandadoc_create_document [#pandadoc_create_document]
Create document
pandadoc_send_document [#pandadoc_send_document]
Send document
pandadoc_list_templates [#pandadoc_list_templates]
List templates
pandadoc_create_session [#pandadoc_create_session]
Create session
Notes [#notes]
* Category: Legal
* Authentication mode: OAuth
# Dropbox Paper Integration
The Dropbox Paper integration provides access to create, update, and export Dropbox Paper documents through the Integrate MCP server.
Installation [#installation]
The Dropbox Paper integration is included with the SDK:
```typescript
import { paperIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Dropbox Paper OAuth App [#1-create-a-dropbox-paper-oauth-app]
1. Go to [Dropbox Developer Portal](https://www.dropbox.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Dropbox Paper integration to your server configuration. The integration automatically reads `PAPER_CLIENT_ID` and `PAPER_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, paperIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
paperIntegration({
scopes: ["account_info.read", "files.metadata.read", "files.content.read", "files.content.write"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
paperIntegration({
clientId: process.env.CUSTOM_PAPER_ID,
clientSecret: process.env.CUSTOM_PAPER_SECRET,
scopes: ["account_info.read", "files.metadata.read", "files.content.read", "files.content.write"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("paper");
const result = await client.paper.createDoc({
path: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, paperIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [paperIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `account_info.read`
* `files.metadata.read`
* `files.content.read`
* `files.content.write`
Tools [#tools]
paper_create_doc [#paper_create_doc]
Create doc
paper_update_doc [#paper_update_doc]
Update doc
paper_export_doc [#paper_export_doc]
Export doc
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# PayPal Integration
The PayPal integration provides access to manage PayPal orders, captures, refunds, invoices, products, plans, and subscriptions through the Integrate MCP server.
Installation [#installation]
The PayPal integration is included with the SDK:
```typescript
import { paypalIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add PayPal to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, paypalIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
paypalIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.paypal.createOrder({
order_json: "value",
});
console.log(result);
```
Environment Variables [#environment-variables]
* `PAYPAL_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
paypal_create_order [#paypal_create_order]
Create order
paypal_get_order [#paypal_get_order]
Get order
paypal_capture_order [#paypal_capture_order]
Capture order
paypal_get_capture [#paypal_get_capture]
Get capture
paypal_refund_capture [#paypal_refund_capture]
Refund capture
paypal_get_refund [#paypal_get_refund]
Get refund
paypal_list_invoices [#paypal_list_invoices]
List invoices
paypal_get_invoice [#paypal_get_invoice]
Get invoice
paypal_create_invoice [#paypal_create_invoice]
Create invoice
paypal_send_invoice [#paypal_send_invoice]
Send invoice
paypal_list_products [#paypal_list_products]
List products
paypal_create_product [#paypal_create_product]
Create product
paypal_list_plans [#paypal_list_plans]
List plans
paypal_create_plan [#paypal_create_plan]
Create plan
paypal_get_subscription [#paypal_get_subscription]
Get subscription
paypal_cancel_subscription [#paypal_cancel_subscription]
Cancel subscription
Notes [#notes]
* Category: Finance
* Authentication mode: API key
# Phantom Integration
The Phantom integration provides access to build Phantom mobile universal links and expose provider deeplink reference data through the Integrate MCP server.
Installation [#installation]
The Phantom integration is included with the SDK:
```typescript
import { phantomIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Phantom to your server configuration:
```typescript
import { createMCPServer, phantomIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
phantomIntegration(),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.phantom.buildBrowseDeeplink({
url: "value",
});
console.log(result);
```
Configuration Options [#configuration-options]
Tools [#tools]
phantom_build_browse_deeplink [#phantom_build_browse_deeplink]
Build browse deeplink
phantom_deeplink_provider_reference [#phantom_deeplink_provider_reference]
Deeplink provider reference
*No parameters.*
Notes [#notes]
* Category: Other
* Authentication mode: None
# Philips Hue Integration
The Philips Hue integration provides access to manage Philips Hue list bridges, list lights, get light, update light, list rooms through the Integrate MCP server.
Installation [#installation]
The Philips Hue integration is included with the SDK:
```typescript
import { philipsHueIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Philips Hue OAuth App [#1-create-a-philips-hue-oauth-app]
1. Create an OAuth application for Philips Hue
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Philips Hue integration to your server configuration. The integration automatically reads `PHILIPS_HUE_CLIENT_ID` and `PHILIPS_HUE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, philipsHueIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
philipsHueIntegration({
scopes: ["remote_control:all"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
philipsHueIntegration({
clientId: process.env.CUSTOM_PHILIPS_HUE_ID,
clientSecret: process.env.CUSTOM_PHILIPS_HUE_SECRET,
scopes: ["remote_control:all"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("philips_hue");
const result = await client.philips_hue.listBridges({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, philipsHueIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [philipsHueIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `remote_control:all`
Tools [#tools]
philips_hue_list_bridges [#philips_hue_list_bridges]
Hue list bridges
*No parameters.*
philips_hue_list_lights [#philips_hue_list_lights]
Hue list lights
*No parameters.*
philips_hue_get_light [#philips_hue_get_light]
Hue get light
philips_hue_update_light [#philips_hue_update_light]
Hue update light
philips_hue_list_rooms [#philips_hue_list_rooms]
Hue list rooms
*No parameters.*
philips_hue_list_scenes [#philips_hue_list_scenes]
Hue list scenes
*No parameters.*
Notes [#notes]
* Category: Lifestyle
* Authentication mode: OAuth
# Pinterest Integration
The Pinterest integration provides access to manage Pinterest boards, pins, search, ad accounts, and campaigns through the Integrate MCP server.
Installation [#installation]
The Pinterest integration is included with the SDK:
```typescript
import { pinterestIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Pinterest OAuth App [#1-create-a-pinterest-oauth-app]
1. Create an OAuth application for Pinterest
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Pinterest integration to your server configuration. The integration automatically reads `PINTEREST_CLIENT_ID` and `PINTEREST_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, pinterestIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
pinterestIntegration({
scopes: ["boards:read", "boards:write", "pins:read", "pins:write", "user_accounts:read", "ads:read", "ads:write"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
pinterestIntegration({
clientId: process.env.CUSTOM_PINTEREST_ID,
clientSecret: process.env.CUSTOM_PINTEREST_SECRET,
scopes: ["boards:read", "boards:write", "pins:read", "pins:write", "user_accounts:read", "ads:read", "ads:write"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("pinterest");
const result = await client.pinterest.getUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, pinterestIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [pinterestIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `boards:read`
* `boards:write`
* `pins:read`
* `pins:write`
* `user_accounts:read`
* `ads:read`
* `ads:write`
Tools [#tools]
pinterest_get_user [#pinterest_get_user]
Get user
*No parameters.*
pinterest_list_boards [#pinterest_list_boards]
List boards
pinterest_get_board [#pinterest_get_board]
Get board
pinterest_create_pin [#pinterest_create_pin]
Create pin
pinterest_get_pin [#pinterest_get_pin]
Get pin
pinterest_search_pins [#pinterest_search_pins]
Search pins
pinterest_list_ad_accounts [#pinterest_list_ad_accounts]
List ad accounts
pinterest_list_campaigns [#pinterest_list_campaigns]
List campaigns
Notes [#notes]
* Category: Social Media
* Authentication mode: OAuth
# Pipedrive Integration
The Pipedrive integration provides access to manage Pipedrive deals, leads, people, organizations, activities, notes, pipelines, and products through the Integrate MCP server.
Installation [#installation]
The Pipedrive integration is included with the SDK:
```typescript
import { pipedriveIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Pipedrive OAuth App [#1-create-a-pipedrive-oauth-app]
1. Create an OAuth application for Pipedrive
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Pipedrive integration to your server configuration. The integration automatically reads `PIPEDRIVE_CLIENT_ID` and `PIPEDRIVE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, pipedriveIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
pipedriveIntegration({
scopes: ["deals:read", "deals:full", "contacts:read", "contacts:full", "activities:read", "activities:full", "products:read", "products:full"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
pipedriveIntegration({
clientId: process.env.CUSTOM_PIPEDRIVE_ID,
clientSecret: process.env.CUSTOM_PIPEDRIVE_SECRET,
scopes: ["deals:read", "deals:full", "contacts:read", "contacts:full", "activities:read", "activities:full", "products:read", "products:full"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("pipedrive");
const result = await client.pipedrive.listDeals({
api_domain: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, pipedriveIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [pipedriveIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `deals:read`
* `deals:full`
* `contacts:read`
* `contacts:full`
* `activities:read`
* `activities:full`
* `products:read`
* `products:full`
Tools [#tools]
pipedrive_list_deals [#pipedrive_list_deals]
List deals
pipedrive_list_leads [#pipedrive_list_leads]
List leads
pipedrive_list_persons [#pipedrive_list_persons]
List persons
pipedrive_list_organizations [#pipedrive_list_organizations]
List organizations
pipedrive_list_activities [#pipedrive_list_activities]
List activities
pipedrive_list_notes [#pipedrive_list_notes]
List notes
pipedrive_list_pipelines [#pipedrive_list_pipelines]
List pipelines
pipedrive_list_products [#pipedrive_list_products]
List products
pipedrive_create_deal [#pipedrive_create_deal]
Create deal
Notes [#notes]
* Category: Business
* Authentication mode: OAuth
# Plaid Integration
The Plaid integration provides access to manage Plaid create link token, exchange public token, get accounts, get transactions, get identity through the Integrate MCP server.
Installation [#installation]
The Plaid integration is included with the SDK:
```typescript
import { plaidIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Plaid OAuth App [#1-create-a-plaid-oauth-app]
1. Create an OAuth application for Plaid
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Plaid integration to your server configuration. The integration automatically reads `PLAID_CLIENT_ID` and `PLAID_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, plaidIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
plaidIntegration({
scopes: ["transactions", "auth", "identity", "accounts", "investments", "liabilities"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
plaidIntegration({
clientId: process.env.CUSTOM_PLAID_ID,
clientSecret: process.env.CUSTOM_PLAID_SECRET,
scopes: ["transactions", "auth", "identity", "accounts", "investments", "liabilities"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("plaid");
const result = await client.plaid.createLinkToken({
link_token_json: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, plaidIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [plaidIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `transactions`
* `auth`
* `identity`
* `accounts`
* `investments`
* `liabilities`
Tools [#tools]
plaid_create_link_token [#plaid_create_link_token]
Create link token
plaid_exchange_public_token [#plaid_exchange_public_token]
Exchange public token
plaid_get_accounts [#plaid_get_accounts]
Get accounts
plaid_get_transactions [#plaid_get_transactions]
Get transactions
plaid_get_identity [#plaid_get_identity]
Get identity
plaid_get_investments [#plaid_get_investments]
Get investments
Notes [#notes]
* Category: Banking
* Authentication mode: OAuth
# PlanetScale Integration
The PlanetScale integration provides access to manage PlanetScale databases, branches, and schema changes through the Integrate MCP server.
Installation [#installation]
The PlanetScale integration is included with the SDK:
```typescript
import { planetscaleIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a PlanetScale OAuth App [#1-create-a-planetscale-oauth-app]
1. Go to [Auth Developer Portal](https://auth.planetscale.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the PlanetScale integration to your server configuration. The integration automatically reads `PLANETSCALE_CLIENT_ID` and `PLANETSCALE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, planetscaleIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
planetscaleIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
planetscaleIntegration({
clientId: process.env.CUSTOM_PLANETSCALE_ID,
clientSecret: process.env.CUSTOM_PLANETSCALE_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("planetscale");
// Use client.planetscale methods after connecting
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, planetscaleIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [planetscaleIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
planetscale_get_current_user [#planetscale_get_current_user]
Get current user
*No parameters.*
planetscale_list_organizations [#planetscale_list_organizations]
List organizations
*No parameters.*
planetscale_get_organization [#planetscale_get_organization]
Get organization
*No parameters.*
planetscale_list_databases [#planetscale_list_databases]
List databases
*No parameters.*
planetscale_get_database [#planetscale_get_database]
Get database
*No parameters.*
planetscale_list_branches [#planetscale_list_branches]
List branches
*No parameters.*
planetscale_get_branch [#planetscale_get_branch]
Get branch
*No parameters.*
planetscale_list_deploy_requests [#planetscale_list_deploy_requests]
List deploy requests
*No parameters.*
planetscale_get_deploy_request [#planetscale_get_deploy_request]
Get deploy request
*No parameters.*
Notes [#notes]
* Category: Infrastructure
* Authentication mode: OAuth
# Microsoft Planner Integration
The Microsoft Planner integration provides access to manage Microsoft Planner plans, buckets, and tasks through the Integrate MCP server.
Installation [#installation]
The Microsoft Planner integration is included with the SDK:
```typescript
import { plannerIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Microsoft Planner OAuth App [#1-create-a-microsoft-planner-oauth-app]
1. Go to [Azure Portal β App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Microsoft Planner integration to your server configuration. The integration automatically reads `PLANNER_CLIENT_ID` and `PLANNER_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, plannerIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
plannerIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
plannerIntegration({
clientId: process.env.CUSTOM_PLANNER_ID,
clientSecret: process.env.CUSTOM_PLANNER_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("planner");
const result = await client.planner.createBucket({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, plannerIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [plannerIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
planner_create_bucket [#planner_create_bucket]
Create bucket
planner_create_plan [#planner_create_plan]
Create plan
planner_create_task [#planner_create_task]
Create task
planner_delete_task [#planner_delete_task]
Delete task
planner_get_plan [#planner_get_plan]
Get plan
planner_get_task [#planner_get_task]
Get task
planner_get_task_details [#planner_get_task_details]
Get task details
planner_list_buckets [#planner_list_buckets]
List buckets
planner_list_group_plans [#planner_list_group_plans]
List group plans
planner_list_my_plans [#planner_list_my_plans]
List my plans
planner_list_my_tasks [#planner_list_my_tasks]
List my tasks
planner_list_plan_tasks [#planner_list_plan_tasks]
List plan tasks
planner_update_task [#planner_update_task]
Update task
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Polar Integration
The Polar integration provides access to manage Polar products, orders, and subscriptions through the Integrate MCP server.
Installation [#installation]
The Polar integration is included with the SDK:
```typescript
import { polarIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Polar OAuth App [#1-create-a-polar-oauth-app]
1. Go to [Polar Settings](https://polar.sh/settings)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Polar integration to your server configuration. The integration automatically reads `POLAR_CLIENT_ID` and `POLAR_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, polarIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
polarIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
polarIntegration({
clientId: process.env.CUSTOM_POLAR_ID,
clientSecret: process.env.CUSTOM_POLAR_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("polar");
const result = await client.polar.listProducts({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, polarIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [polarIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
polar_list_products [#polar_list_products]
List products
polar_get_product [#polar_get_product]
Get product details
polar_create_product [#polar_create_product]
Create a new product
polar_update_product [#polar_update_product]
Update a product
polar_list_subscriptions [#polar_list_subscriptions]
List subscriptions
polar_get_subscription [#polar_get_subscription]
Get subscription details
polar_update_subscription [#polar_update_subscription]
Update a subscription
polar_revoke_subscription [#polar_revoke_subscription]
Revoke a subscription
polar_list_customers [#polar_list_customers]
List customers
polar_get_customer [#polar_get_customer]
Get customer details
polar_create_customer [#polar_create_customer]
Create a new customer
polar_update_customer [#polar_update_customer]
Update a customer
polar_delete_customer [#polar_delete_customer]
Delete a customer
polar_get_customer_state [#polar_get_customer_state]
Get customer state (subscriptions, orders, etc.)
polar_list_orders [#polar_list_orders]
List orders
polar_get_order [#polar_get_order]
Get order details
polar_get_order_invoice [#polar_get_order_invoice]
Get order invoice
polar_list_benefits [#polar_list_benefits]
List benefits
polar_get_benefit [#polar_get_benefit]
Get benefit details
polar_create_benefit [#polar_create_benefit]
Create a new benefit
polar_update_benefit [#polar_update_benefit]
Update a benefit
polar_list_discounts [#polar_list_discounts]
List discounts
polar_get_discount [#polar_get_discount]
Get discount details
polar_create_discount [#polar_create_discount]
Create a new discount
polar_delete_discount [#polar_delete_discount]
Delete a discount
polar_list_checkout_links [#polar_list_checkout_links]
List checkout links
polar_get_checkout_link [#polar_get_checkout_link]
Get checkout link details
polar_create_checkout_link [#polar_create_checkout_link]
Create a new checkout link
polar_list_license_keys [#polar_list_license_keys]
List license keys
polar_get_license_key [#polar_get_license_key]
Get license key details
polar_validate_license_key [#polar_validate_license_key]
Validate a license key
polar_activate_license_key [#polar_activate_license_key]
Activate a license key
polar_get_metrics [#polar_get_metrics]
Get metrics for a time period
polar_list_organizations [#polar_list_organizations]
List organizations
polar_get_organization [#polar_get_organization]
Get organization details
Notes [#notes]
* Category: Finance
* Authentication mode: OAuth
# PostHog Integration
The PostHog integration provides access to read PostHog organizations, projects, insights, flags, and analytics data through the Integrate MCP server.
Installation [#installation]
The PostHog integration is included with the SDK:
```typescript
import { posthogIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a PostHog OAuth App [#1-create-a-posthog-oauth-app]
1. Create an OAuth application for PostHog
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the PostHog integration to your server configuration. The integration automatically reads `POSTHOG_CLIENT_ID` and `POSTHOG_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, posthogIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
posthogIntegration({
scopes: ["openid", "profile", "email", "organization:read", "project:read", "user:read", "query:read", "insight:read", "dashboard:read", "feature_flag:read", "experiment:read", "annotation:read", "cohort:read", "person:read", "event_definition:read", "property_definition:read", "session_recording:read", "action:read"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
posthogIntegration({
clientId: process.env.CUSTOM_POSTHOG_ID,
clientSecret: process.env.CUSTOM_POSTHOG_SECRET,
scopes: ["openid", "profile", "email", "organization:read", "project:read", "user:read", "query:read", "insight:read", "dashboard:read", "feature_flag:read", "experiment:read", "annotation:read", "cohort:read", "person:read", "event_definition:read", "property_definition:read", "session_recording:read", "action:read"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("posthog");
const result = await client.posthog.getCurrentUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, posthogIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [posthogIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `openid`
* `profile`
* `email`
* `organization:read`
* `project:read`
* `user:read`
* `query:read`
* `insight:read`
* `dashboard:read`
* `feature_flag:read`
* `experiment:read`
* `annotation:read`
* `cohort:read`
* `person:read`
* `event_definition:read`
* `property_definition:read`
* `session_recording:read`
* `action:read`
Tools [#tools]
posthog_get_current_user [#posthog_get_current_user]
Get current user
*No parameters.*
posthog_list_organizations [#posthog_list_organizations]
List organizations
posthog_get_organization [#posthog_get_organization]
Get organization
posthog_list_projects [#posthog_list_projects]
List projects
posthog_get_project [#posthog_get_project]
Get project
posthog_run_hogql_query [#posthog_run_hogql_query]
Run hogql query
posthog_list_insights [#posthog_list_insights]
List insights
posthog_get_insight [#posthog_get_insight]
Get insight
posthog_list_dashboards [#posthog_list_dashboards]
List dashboards
posthog_get_dashboard [#posthog_get_dashboard]
Get dashboard
posthog_list_feature_flags [#posthog_list_feature_flags]
List feature flags
posthog_get_feature_flag [#posthog_get_feature_flag]
Get feature flag
posthog_list_experiments [#posthog_list_experiments]
List experiments
posthog_get_experiment [#posthog_get_experiment]
Get experiment
posthog_list_annotations [#posthog_list_annotations]
List annotations
posthog_get_annotation [#posthog_get_annotation]
Get annotation
posthog_list_cohorts [#posthog_list_cohorts]
List cohorts
posthog_get_cohort [#posthog_get_cohort]
Get cohort
posthog_list_event_definitions [#posthog_list_event_definitions]
List event definitions
posthog_get_event_definition [#posthog_get_event_definition]
Get event definition
posthog_list_property_definitions [#posthog_list_property_definitions]
List property definitions
posthog_get_property_definition [#posthog_get_property_definition]
Get property definition
posthog_list_persons [#posthog_list_persons]
List persons
posthog_get_person [#posthog_get_person]
Get person
posthog_list_session_recordings [#posthog_list_session_recordings]
List session recordings
posthog_get_session_recording [#posthog_get_session_recording]
Get session recording
Notes [#notes]
* Category: Analytics
* Authentication mode: OAuth
# Postman Integration
The Postman integration provides access to manage Postman workspaces, collections, and environments via the Postman API through the Integrate MCP server.
Installation [#installation]
The Postman integration is included with the SDK:
```typescript
import { postmanIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Postman to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, postmanIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
postmanIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.postman.getMe({});
console.log(result);
```
Environment Variables [#environment-variables]
* `POSTMAN_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
postman_get_me [#postman_get_me]
Get me
*No parameters.*
postman_list_workspaces [#postman_list_workspaces]
List workspaces
postman_get_workspace [#postman_get_workspace]
Get workspace
postman_list_collections [#postman_list_collections]
List collections
postman_get_collection [#postman_get_collection]
Get collection
postman_delete_collection [#postman_delete_collection]
Delete collection
postman_list_environments [#postman_list_environments]
List environments
postman_get_environment [#postman_get_environment]
Get environment
postman_create_collection [#postman_create_collection]
Create collection
Notes [#notes]
* Category: Engineering
* Authentication mode: API key
# PowerPoint Integration
The PowerPoint integration provides access to manage PowerPoint presentations and sharing through the Integrate MCP server.
Installation [#installation]
The PowerPoint integration is included with the SDK:
```typescript
import { powerpointIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a PowerPoint OAuth App [#1-create-a-powerpoint-oauth-app]
1. Go to [Azure Portal β App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the PowerPoint integration to your server configuration. The integration automatically reads `POWERPOINT_CLIENT_ID` and `POWERPOINT_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, powerpointIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
powerpointIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
powerpointIntegration({
clientId: process.env.CUSTOM_POWERPOINT_ID,
clientSecret: process.env.CUSTOM_POWERPOINT_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("powerpoint");
const result = await client.powerpoint.list({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, powerpointIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [powerpointIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
powerpoint_copy [#powerpoint_copy]
Copy a presentation
powerpoint_create [#powerpoint_create]
Create a new empty .pptx file in OneDrive
powerpoint_delete [#powerpoint_delete]
Delete a presentation permanently
powerpoint_get [#powerpoint_get]
Get metadata for a presentation
powerpoint_list [#powerpoint_list]
Search for PowerPoint presentations
powerpoint_share [#powerpoint_share]
Create a sharing link for a presentation
powerpoint_update_content [#powerpoint_update_content]
Update content
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# QuickBooks Online Integration
The QuickBooks Online integration provides access to manage QuickBooks Online company data, customers, vendors, items, accounts, invoices, bills, payments, reports, and queries through the Integrate MCP server.
Installation [#installation]
The QuickBooks Online integration is included with the SDK:
```typescript
import { quickbooksIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a QuickBooks Online OAuth App [#1-create-a-quickbooks-online-oauth-app]
1. Create an OAuth application for QuickBooks Online
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the QuickBooks Online integration to your server configuration. The integration automatically reads `QUICKBOOKS_CLIENT_ID` and `QUICKBOOKS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, quickbooksIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
quickbooksIntegration({
scopes: ["com.intuit.quickbooks.accounting", "openid", "profile", "email", "offline_access"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
quickbooksIntegration({
clientId: process.env.CUSTOM_QUICKBOOKS_ID,
clientSecret: process.env.CUSTOM_QUICKBOOKS_SECRET,
scopes: ["com.intuit.quickbooks.accounting", "openid", "profile", "email", "offline_access"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("quickbooks");
const result = await client.quickbooks.getCompanyInfo({
company_id: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, quickbooksIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [quickbooksIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `com.intuit.quickbooks.accounting`
* `openid`
* `profile`
* `email`
* `offline_access`
Tools [#tools]
quickbooks_get_company_info [#quickbooks_get_company_info]
Get company info
quickbooks_query [#quickbooks_query]
Query
quickbooks_list_customers [#quickbooks_list_customers]
List customers
quickbooks_get_customer [#quickbooks_get_customer]
Get customer
quickbooks_create_customer [#quickbooks_create_customer]
Create customer
quickbooks_list_vendors [#quickbooks_list_vendors]
List vendors
quickbooks_create_vendor [#quickbooks_create_vendor]
Create vendor
quickbooks_list_items [#quickbooks_list_items]
List items
quickbooks_create_item [#quickbooks_create_item]
Create item
quickbooks_list_accounts [#quickbooks_list_accounts]
List accounts
quickbooks_list_invoices [#quickbooks_list_invoices]
List invoices
quickbooks_get_invoice [#quickbooks_get_invoice]
Get invoice
quickbooks_create_invoice [#quickbooks_create_invoice]
Create invoice
quickbooks_list_bills [#quickbooks_list_bills]
List bills
quickbooks_create_bill [#quickbooks_create_bill]
Create bill
quickbooks_create_payment [#quickbooks_create_payment]
Create payment
quickbooks_get_report [#quickbooks_get_report]
Get report
Notes [#notes]
* Category: Accounting
* Authentication mode: OAuth
# Railway Integration
The Railway integration provides access to manage Railway workspaces, projects, services, deployments, variables, domains, and volumes through the Integrate MCP server.
Installation [#installation]
The Railway integration is included with the SDK:
```typescript
import { railwayIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Railway OAuth App [#1-create-a-railway-oauth-app]
1. Go to [Backboard Developer Portal](https://backboard.railway.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Railway integration to your server configuration. The integration automatically reads `RAILWAY_CLIENT_ID` and `RAILWAY_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, railwayIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
railwayIntegration({
scopes: ["openid", "profile", "email", "workspace:admin", "project:member"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
railwayIntegration({
clientId: process.env.CUSTOM_RAILWAY_ID,
clientSecret: process.env.CUSTOM_RAILWAY_SECRET,
scopes: ["openid", "profile", "email", "workspace:admin", "project:member"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("railway");
const result = await client.railway.getCurrentUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, railwayIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [railwayIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `openid`
* `profile`
* `email`
* `workspace:admin`
* `project:member`
Tools [#tools]
railway_get_current_user [#railway_get_current_user]
Get current user
*No parameters.*
railway_get_workspace [#railway_get_workspace]
Get workspace
railway_list_regions [#railway_list_regions]
List regions
*No parameters.*
railway_list_projects [#railway_list_projects]
List projects
railway_get_project [#railway_get_project]
Get project
railway_create_project [#railway_create_project]
Create project
railway_update_project [#railway_update_project]
Update project
railway_delete_project [#railway_delete_project]
Delete project
railway_transfer_project [#railway_transfer_project]
Transfer project
railway_list_project_members [#railway_list_project_members]
List project members
railway_list_environments [#railway_list_environments]
List environments
railway_get_environment [#railway_get_environment]
Get environment
railway_create_environment [#railway_create_environment]
Create environment
railway_rename_environment [#railway_rename_environment]
Rename environment
railway_delete_environment [#railway_delete_environment]
Delete environment
railway_get_environment_logs [#railway_get_environment_logs]
Get environment logs
railway_get_environment_staged_changes [#railway_get_environment_staged_changes]
Get environment staged changes
railway_commit_environment_staged_changes [#railway_commit_environment_staged_changes]
Commit environment staged changes
railway_get_service [#railway_get_service]
Get service
railway_get_service_instance [#railway_get_service_instance]
Get service instance
railway_create_service [#railway_create_service]
Create service
railway_update_service [#railway_update_service]
Update service
railway_update_service_instance [#railway_update_service_instance]
Update service instance
railway_connect_service [#railway_connect_service]
Connect service
railway_disconnect_service [#railway_disconnect_service]
Disconnect service
railway_deploy_service [#railway_deploy_service]
Deploy service
railway_redeploy_service [#railway_redeploy_service]
Redeploy service
railway_get_service_limits [#railway_get_service_limits]
Get service limits
railway_delete_service [#railway_delete_service]
Delete service
railway_list_deployments [#railway_list_deployments]
List deployments
railway_get_deployment [#railway_get_deployment]
Get deployment
railway_get_latest_active_deployment [#railway_get_latest_active_deployment]
Get latest active deployment
railway_get_deployment_build_logs [#railway_get_deployment_build_logs]
Get deployment build logs
railway_get_deployment_runtime_logs [#railway_get_deployment_runtime_logs]
Get deployment runtime logs
railway_get_deployment_http_logs [#railway_get_deployment_http_logs]
Get deployment http logs
railway_redeploy_deployment [#railway_redeploy_deployment]
Redeploy deployment
railway_restart_deployment [#railway_restart_deployment]
Restart deployment
railway_rollback_deployment [#railway_rollback_deployment]
Rollback deployment
railway_stop_deployment [#railway_stop_deployment]
Stop deployment
railway_cancel_deployment [#railway_cancel_deployment]
Cancel deployment
railway_remove_deployment [#railway_remove_deployment]
Remove deployment
railway_get_variables [#railway_get_variables]
Get variables
railway_get_unrendered_variables [#railway_get_unrendered_variables]
Get unrendered variables
railway_upsert_variable [#railway_upsert_variable]
Upsert variable
railway_upsert_variables [#railway_upsert_variables]
Upsert variables
railway_delete_variable [#railway_delete_variable]
Delete variable
railway_get_rendered_variables [#railway_get_rendered_variables]
Get rendered variables
railway_list_domains [#railway_list_domains]
List domains
railway_create_service_domain [#railway_create_service_domain]
Create service domain
railway_delete_service_domain [#railway_delete_service_domain]
Delete service domain
railway_check_custom_domain_availability [#railway_check_custom_domain_availability]
Check custom domain availability
railway_create_custom_domain [#railway_create_custom_domain]
Create custom domain
railway_get_custom_domain_status [#railway_get_custom_domain_status]
Get custom domain status
railway_update_custom_domain [#railway_update_custom_domain]
Update custom domain
railway_delete_custom_domain [#railway_delete_custom_domain]
Delete custom domain
railway_list_project_volumes [#railway_list_project_volumes]
List project volumes
railway_get_volume_instance [#railway_get_volume_instance]
Get volume instance
railway_create_volume [#railway_create_volume]
Create volume
railway_update_volume [#railway_update_volume]
Update volume
railway_update_volume_instance [#railway_update_volume_instance]
Update volume instance
railway_delete_volume [#railway_delete_volume]
Delete volume
railway_list_volume_backups [#railway_list_volume_backups]
List volume backups
railway_create_volume_backup [#railway_create_volume_backup]
Create volume backup
railway_restore_volume_backup [#railway_restore_volume_backup]
Restore volume backup
railway_lock_volume_backup [#railway_lock_volume_backup]
Lock volume backup
railway_delete_volume_backup [#railway_delete_volume_backup]
Delete volume backup
railway_list_volume_backup_schedules [#railway_list_volume_backup_schedules]
List volume backup schedules
railway_list_tcp_proxies [#railway_list_tcp_proxies]
List tcp proxies
Notes [#notes]
* Category: Infrastructure
* Authentication mode: OAuth
# Ramp Integration
The Ramp integration provides access to manage Ramp corporate cards, bills, reimbursements, and spend controls through the Integrate MCP server.
Installation [#installation]
The Ramp integration is included with the SDK:
```typescript
import { rampIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Ramp OAuth App [#1-create-a-ramp-oauth-app]
1. Go to [Ramp Developer Portal](https://app.ramp.com/developer)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Ramp integration to your server configuration. The integration automatically reads `RAMP_CLIENT_ID` and `RAMP_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, rampIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
rampIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
rampIntegration({
clientId: process.env.CUSTOM_RAMP_ID,
clientSecret: process.env.CUSTOM_RAMP_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("ramp");
const result = await client.ramp.listTransactions({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, rampIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [rampIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
ramp_list_transactions [#ramp_list_transactions]
List transactions
ramp_get_transaction [#ramp_get_transaction]
Get transaction details
ramp_list_cards [#ramp_list_cards]
List cards
ramp_get_card [#ramp_get_card]
Get card details
ramp_list_users [#ramp_list_users]
List users
ramp_get_user [#ramp_get_user]
Get user details
ramp_list_departments [#ramp_list_departments]
List departments
ramp_list_reimbursements [#ramp_list_reimbursements]
List reimbursements
ramp_get_spend_limits [#ramp_get_spend_limits]
Get spend limits
Notes [#notes]
* Category: Finance
* Authentication mode: OAuth
# Reddit Integration
The Reddit integration provides access to browse subreddits, search posts, submit content, and vote on Reddit through the Integrate MCP server.
Installation [#installation]
The Reddit integration is included with the SDK:
```typescript
import { redditIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Reddit OAuth App [#1-create-a-reddit-oauth-app]
1. Create an OAuth application for Reddit
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Reddit integration to your server configuration. The integration automatically reads `REDDIT_CLIENT_ID` and `REDDIT_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, redditIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
redditIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
redditIntegration({
clientId: process.env.CUSTOM_REDDIT_ID,
clientSecret: process.env.CUSTOM_REDDIT_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("reddit");
// Use client.reddit methods after connecting
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, redditIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [redditIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
reddit_get_me [#reddit_get_me]
Get me
*No parameters.*
reddit_get_subreddit_about [#reddit_get_subreddit_about]
Get subreddit about
*No parameters.*
reddit_list_subreddit_posts [#reddit_list_subreddit_posts]
List subreddit posts
*No parameters.*
reddit_get_post_thread [#reddit_get_post_thread]
Get post thread
*No parameters.*
reddit_search [#reddit_search]
Search
*No parameters.*
reddit_submit_post [#reddit_submit_post]
Submit post
*No parameters.*
reddit_comment [#reddit_comment]
Comment
*No parameters.*
reddit_vote [#reddit_vote]
Vote
*No parameters.*
reddit_list_my_subreddits [#reddit_list_my_subreddits]
List my subreddits
*No parameters.*
reddit_list_popular_subreddits [#reddit_list_popular_subreddits]
List popular subreddits
*No parameters.*
Notes [#notes]
* Category: Social Media
* Authentication mode: OAuth
# Redis Cloud Integration
The Redis Cloud integration provides access to manage Redis Cloud subscriptions, databases, async tasks, and audit logs via the REST API through the Integrate MCP server.
Installation [#installation]
The Redis Cloud integration is included with the SDK:
```typescript
import { redisIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Redis Cloud to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, redisIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
redisIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.redis.listSubscriptions({});
console.log(result);
```
Environment Variables [#environment-variables]
* `REDIS_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
redis_list_subscriptions [#redis_list_subscriptions]
List subscriptions
*No parameters.*
redis_get_subscription [#redis_get_subscription]
Get subscription
redis_list_fixed_subscriptions [#redis_list_fixed_subscriptions]
List fixed subscriptions
*No parameters.*
redis_get_fixed_subscription [#redis_get_fixed_subscription]
Get fixed subscription
redis_list_databases [#redis_list_databases]
List databases
redis_get_database [#redis_get_database]
Get database
redis_create_database [#redis_create_database]
Create database
redis_update_database [#redis_update_database]
Update database
redis_delete_database [#redis_delete_database]
Delete database
redis_list_essentials_databases [#redis_list_essentials_databases]
List essentials databases
redis_get_essentials_database [#redis_get_essentials_database]
Get essentials database
redis_create_essentials_database [#redis_create_essentials_database]
Create essentials database
redis_update_essentials_database [#redis_update_essentials_database]
Update essentials database
redis_delete_essentials_database [#redis_delete_essentials_database]
Delete essentials database
redis_get_task [#redis_get_task]
Get task
redis_list_logs [#redis_list_logs]
List logs
Notes [#notes]
* Category: Infrastructure
* Authentication mode: API key
# Resend Integration
The Resend integration provides access to send email and manage domains with the Resend API through the Integrate MCP server.
Installation [#installation]
The Resend integration is included with the SDK:
```typescript
import { resendIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Resend to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, resendIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
resendIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
// Use client.resend methods after connecting
```
Environment Variables [#environment-variables]
* `RESEND_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
resend_list_domains [#resend_list_domains]
List domains
*No parameters.*
resend_get_domain [#resend_get_domain]
Get domain
*No parameters.*
resend_create_domain [#resend_create_domain]
Create domain
*No parameters.*
resend_delete_domain [#resend_delete_domain]
Delete domain
*No parameters.*
resend_verify_domain [#resend_verify_domain]
Verify domain
*No parameters.*
resend_send_email [#resend_send_email]
Send email
*No parameters.*
resend_get_email [#resend_get_email]
Get email
*No parameters.*
resend_cancel_scheduled_email [#resend_cancel_scheduled_email]
Cancel scheduled email
*No parameters.*
Notes [#notes]
* Category: Communication
* Authentication mode: API key
# Ring Integration
The Ring integration provides access to manage Ring list locations, list devices, get device health, list events, activate siren through the Integrate MCP server.
Installation [#installation]
The Ring integration is included with the SDK:
```typescript
import { ringIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Ring OAuth App [#1-create-a-ring-oauth-app]
1. Create an OAuth application for Ring
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Ring integration to your server configuration. The integration automatically reads `RING_CLIENT_ID` and `RING_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, ringIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
ringIntegration({
scopes: ["openid", "profile", "offline_access"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
ringIntegration({
clientId: process.env.CUSTOM_RING_ID,
clientSecret: process.env.CUSTOM_RING_SECRET,
scopes: ["openid", "profile", "offline_access"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("ring");
const result = await client.ring.listLocations({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, ringIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [ringIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `openid`
* `profile`
* `offline_access`
Tools [#tools]
ring_list_locations [#ring_list_locations]
List locations
*No parameters.*
ring_list_devices [#ring_list_devices]
List devices
ring_get_device_health [#ring_get_device_health]
Get device health
ring_list_events [#ring_list_events]
List events
ring_activate_siren [#ring_activate_siren]
Activate siren
Notes [#notes]
* Category: Lifestyle
* Authentication mode: OAuth
# Sage Integration
The Sage integration provides access to manage Sage business details, contacts, products, and sales invoices through the Integrate MCP server.
Installation [#installation]
The Sage integration is included with the SDK:
```typescript
import { sageIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Sage OAuth App [#1-create-a-sage-oauth-app]
1. Create an OAuth application for Sage
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Sage integration to your server configuration. The integration automatically reads `SAGE_CLIENT_ID` and `SAGE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, sageIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
sageIntegration({
scopes: ["full_access"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
sageIntegration({
clientId: process.env.CUSTOM_SAGE_ID,
clientSecret: process.env.CUSTOM_SAGE_SECRET,
scopes: ["full_access"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("sage");
const result = await client.sage.getBusiness({
business_id: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, sageIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [sageIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `full_access`
Tools [#tools]
sage_get_business [#sage_get_business]
Get business
sage_list_contacts [#sage_list_contacts]
List contacts
sage_create_contact [#sage_create_contact]
Create contact
sage_list_products [#sage_list_products]
List products
sage_list_sales_invoices [#sage_list_sales_invoices]
List sales invoices
sage_create_sales_invoice [#sage_create_sales_invoice]
Create sales invoice
Notes [#notes]
* Category: Accounting
* Authentication mode: OAuth
# Salesforce Integration
The Salesforce integration provides access to manage Salesforce accounts, contacts, opportunities, and cases through the Integrate MCP server.
Installation [#installation]
The Salesforce integration is included with the SDK:
```typescript
import { salesforceIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Salesforce OAuth App [#1-create-a-salesforce-oauth-app]
1. Create an OAuth application for Salesforce
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Salesforce integration to your server configuration. The integration automatically reads `SALESFORCE_CLIENT_ID` and `SALESFORCE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, salesforceIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
salesforceIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
salesforceIntegration({
clientId: process.env.CUSTOM_SALESFORCE_ID,
clientSecret: process.env.CUSTOM_SALESFORCE_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("salesforce");
const result = await client.salesforce.query({
q: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, salesforceIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [salesforceIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
salesforce_query [#salesforce_query]
Query
salesforce_get_limits [#salesforce_get_limits]
Get limits
salesforce_describe_global [#salesforce_describe_global]
Describe global
salesforce_sobject_describe [#salesforce_sobject_describe]
Sobject describe
salesforce_sobject_get [#salesforce_sobject_get]
Sobject get
salesforce_sobject_create [#salesforce_sobject_create]
Sobject create
salesforce_sobject_update [#salesforce_sobject_update]
Sobject update
salesforce_sobject_delete [#salesforce_sobject_delete]
Sobject delete
Notes [#notes]
* Category: Business
* Authentication mode: OAuth
# Sentry Integration
The Sentry integration provides access to monitor Sentry errors, issues, releases, and projects through the Integrate MCP server.
Installation [#installation]
The Sentry integration is included with the SDK:
```typescript
import { sentryIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Sentry OAuth App [#1-create-a-sentry-oauth-app]
1. Go to [Sentry Developer Portal](https://sentry.io)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Sentry integration to your server configuration. The integration automatically reads `SENTRY_CLIENT_ID` and `SENTRY_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, sentryIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
sentryIntegration({
scopes: ["org:read", "project:read", "team:read", "member:read", "event:read", "event:write", "project:releases"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
sentryIntegration({
clientId: process.env.CUSTOM_SENTRY_ID,
clientSecret: process.env.CUSTOM_SENTRY_SECRET,
scopes: ["org:read", "project:read", "team:read", "member:read", "event:read", "event:write", "project:releases"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("sentry");
const result = await client.sentry.getOrganization({
org_slug: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, sentryIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [sentryIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `org:read`
* `project:read`
* `team:read`
* `member:read`
* `event:read`
* `event:write`
* `project:releases`
Tools [#tools]
sentry_get_organization [#sentry_get_organization]
Get organization
sentry_list_org_projects [#sentry_list_org_projects]
List org projects
sentry_list_org_members [#sentry_list_org_members]
List org members
sentry_get_project [#sentry_get_project]
Get project
sentry_list_issues [#sentry_list_issues]
List issues
sentry_get_issue [#sentry_get_issue]
Get issue
sentry_update_issue [#sentry_update_issue]
Update issue
sentry_list_issue_events [#sentry_list_issue_events]
List issue events
sentry_list_project_events [#sentry_list_project_events]
List project events
sentry_list_releases [#sentry_list_releases]
List releases
sentry_get_release [#sentry_get_release]
Get release
sentry_create_release [#sentry_create_release]
Create release
sentry_list_release_commits [#sentry_list_release_commits]
List release commits
sentry_resolve_short_id [#sentry_resolve_short_id]
Resolve short id
Notes [#notes]
* Category: Engineering
* Authentication mode: OAuth
# SharePoint Integration
The SharePoint integration provides access to search SharePoint sites and manage drives, files, folders, and sharing links through the Integrate MCP server.
Installation [#installation]
The SharePoint integration is included with the SDK:
```typescript
import { sharepointIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a SharePoint OAuth App [#1-create-a-sharepoint-oauth-app]
1. Go to [Azure Portal β App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the SharePoint integration to your server configuration. The integration automatically reads `SHAREPOINT_CLIENT_ID` and `SHAREPOINT_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, sharepointIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
sharepointIntegration({
scopes: ["Sites.ReadWrite.All", "Files.ReadWrite.All", "offline_access"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
sharepointIntegration({
clientId: process.env.CUSTOM_SHAREPOINT_ID,
clientSecret: process.env.CUSTOM_SHAREPOINT_SECRET,
scopes: ["Sites.ReadWrite.All", "Files.ReadWrite.All", "offline_access"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("sharepoint");
const result = await client.sharepoint.createFolder({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, sharepointIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [sharepointIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `Sites.ReadWrite.All`
* `Files.ReadWrite.All`
* `offline_access`
Tools [#tools]
sharepoint_create_folder [#sharepoint_create_folder]
Create folder
sharepoint_delete_item [#sharepoint_delete_item]
Delete item
sharepoint_get_item [#sharepoint_get_item]
Get item
sharepoint_get_site [#sharepoint_get_site]
Get site
sharepoint_list_drives [#sharepoint_list_drives]
List drives
sharepoint_list_items [#sharepoint_list_items]
List items
sharepoint_search_files [#sharepoint_search_files]
Search files
sharepoint_search_sites [#sharepoint_search_sites]
Search sites
sharepoint_share_item [#sharepoint_share_item]
Share item
sharepoint_update_item [#sharepoint_update_item]
Update item
sharepoint_upload_file [#sharepoint_upload_file]
Upload file
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Shopify Integration
The Shopify integration provides access to route-complete Shopify Admin access through GraphQL and REST tools through the Integrate MCP server.
Installation [#installation]
The Shopify integration is included with the SDK:
```typescript
import { shopifyIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Shopify OAuth App [#1-create-a-shopify-oauth-app]
1. Go to [Shopify Developer Portal](https://shopify.oauth.placeholder)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Shopify integration to your server configuration. The integration automatically reads `SHOPIFY_CLIENT_ID` and `SHOPIFY_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, shopifyIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
shopifyIntegration({
scopes: ["read_products", "write_products", "read_orders", "write_orders", "read_customers", "write_customers", "read_inventory", "write_inventory", "read_content", "write_content", "read_fulfillments", "write_fulfillments", "read_analytics"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
shopifyIntegration({
clientId: process.env.CUSTOM_SHOPIFY_ID,
clientSecret: process.env.CUSTOM_SHOPIFY_SECRET,
scopes: ["read_products", "write_products", "read_orders", "write_orders", "read_customers", "write_customers", "read_inventory", "write_inventory", "read_content", "write_content", "read_fulfillments", "write_fulfillments", "read_analytics"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("shopify");
const result = await client.shopify.adminGraphql({
query: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, shopifyIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [shopifyIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `read_products`
* `write_products`
* `read_orders`
* `write_orders`
* `read_customers`
* `write_customers`
* `read_inventory`
* `write_inventory`
* `read_content`
* `write_content`
* `read_fulfillments`
* `write_fulfillments`
* `read_analytics`
Tools [#tools]
shopify_admin_graphql [#shopify_admin_graphql]
Admin graphql
shopify_rest_get [#shopify_rest_get]
Rest get
shopify_rest_post [#shopify_rest_post]
Rest post
shopify_rest_put [#shopify_rest_put]
Rest put
shopify_rest_delete [#shopify_rest_delete]
Rest delete
shopify_get_shop [#shopify_get_shop]
Get shop
Notes [#notes]
* Category: Commerce
* Authentication mode: OAuth
# Slack Integration
The Slack integration provides access to send and manage Slack messages and channels through the Integrate MCP server.
Installation [#installation]
The Slack integration is included with the SDK:
```typescript
import { slackIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Slack OAuth App [#1-create-a-slack-oauth-app]
1. Go to [Slack API Apps](https://api.slack.com/apps)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Slack integration to your server configuration. The integration automatically reads `SLACK_CLIENT_ID` and `SLACK_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, slackIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
slackIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
slackIntegration({
clientId: process.env.CUSTOM_SLACK_ID,
clientSecret: process.env.CUSTOM_SLACK_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("slack");
const result = await client.slack.sendMessage({
channel: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, slackIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [slackIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
slack_send_message [#slack_send_message]
Send a message to a Slack channel
slack_list_messages [#slack_list_messages]
Get message history from a channel
slack_get_thread_replies [#slack_get_thread_replies]
Get all replies in a message thread
slack_update_message [#slack_update_message]
Update the text of an existing message
slack_delete_message [#slack_delete_message]
Delete a message
slack_schedule_message [#slack_schedule_message]
Schedule a message to be sent at a future time
slack_get_permalink [#slack_get_permalink]
Get a permanent URL for a specific message
slack_search_messages [#slack_search_messages]
Search for messages across the workspace
slack_list_channels [#slack_list_channels]
List channels in the workspace
slack_get_channel [#slack_get_channel]
Get details about a specific channel
slack_create_channel [#slack_create_channel]
Create a new channel
slack_invite_to_channel [#slack_invite_to_channel]
Invite one or more users to a channel
slack_list_channel_members [#slack_list_channel_members]
List all members of a channel
slack_set_channel_topic [#slack_set_channel_topic]
Set the topic of a channel
slack_archive_channel [#slack_archive_channel]
Archive a channel
slack_list_users [#slack_list_users]
List all users in the workspace
slack_get_user [#slack_get_user]
Get detailed profile for a user
slack_lookup_user_by_email [#slack_lookup_user_by_email]
Find a user by their email address
slack_add_reaction [#slack_add_reaction]
Add an emoji reaction to a message
slack_remove_reaction [#slack_remove_reaction]
Remove an emoji reaction from a message
slack_get_reactions [#slack_get_reactions]
Get all reactions on a message
slack_upload_file [#slack_upload_file]
Upload a text file to one or more channels
slack_pin_message [#slack_pin_message]
Pin a message in a channel
slack_unpin_message [#slack_unpin_message]
Unpin a message in a channel
slack_list_pins [#slack_list_pins]
List all pinned items in a channel
slack_set_channel_purpose [#slack_set_channel_purpose]
Set the purpose of a channel
slack_rename_channel [#slack_rename_channel]
Rename a channel
slack_join_channel [#slack_join_channel]
Join a channel
slack_leave_channel [#slack_leave_channel]
Leave a channel
slack_kick_from_channel [#slack_kick_from_channel]
Remove a user from a channel
slack_unarchive_channel [#slack_unarchive_channel]
Unarchive a channel
slack_open_dm [#slack_open_dm]
Open or resume a direct message conversation with one or more users
slack_get_user_presence [#slack_get_user_presence]
Get the presence status of a user
slack_get_dnd_info [#slack_get_dnd_info]
Get Do Not Disturb status for a user
slack_list_files [#slack_list_files]
List files in the workspace
slack_get_file [#slack_get_file]
Get info about a file
slack_delete_file [#slack_delete_file]
Delete a file
slack_get_team_info [#slack_get_team_info]
Get information about the current workspace/team
*No parameters.*
slack_list_bookmarks [#slack_list_bookmarks]
List bookmarks for a channel
slack_add_bookmark [#slack_add_bookmark]
Add a bookmark to a channel
slack_list_reminders [#slack_list_reminders]
List reminders for the authenticated user
*No parameters.*
slack_add_reminder [#slack_add_reminder]
Create a reminder for the authenticated user
slack_list_usergroups [#slack_list_usergroups]
List user groups in the workspace
Notes [#notes]
* Category: Communication
* Authentication mode: OAuth
# Smartsheet Integration
The Smartsheet integration provides access to manage Smartsheet sheets, rows, columns, workspaces, reports, and attachments through the Integrate MCP server.
Installation [#installation]
The Smartsheet integration is included with the SDK:
```typescript
import { smartsheetIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Smartsheet OAuth App [#1-create-a-smartsheet-oauth-app]
1. Create an OAuth application for Smartsheet
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Smartsheet integration to your server configuration. The integration automatically reads `SMARTSHEET_CLIENT_ID` and `SMARTSHEET_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, smartsheetIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
smartsheetIntegration({
scopes: ["READ_SHEETS", "WRITE_SHEETS", "ADMIN_SHEETS", "READ_USERS", "READ_WORKSPACES", "ADMIN_WORKSPACES"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
smartsheetIntegration({
clientId: process.env.CUSTOM_SMARTSHEET_ID,
clientSecret: process.env.CUSTOM_SMARTSHEET_SECRET,
scopes: ["READ_SHEETS", "WRITE_SHEETS", "ADMIN_SHEETS", "READ_USERS", "READ_WORKSPACES", "ADMIN_WORKSPACES"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("smartsheet");
const result = await client.smartsheet.listSheets({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, smartsheetIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [smartsheetIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `READ_SHEETS`
* `WRITE_SHEETS`
* `ADMIN_SHEETS`
* `READ_USERS`
* `READ_WORKSPACES`
* `ADMIN_WORKSPACES`
Tools [#tools]
smartsheet_list_sheets [#smartsheet_list_sheets]
List sheets
smartsheet_get_sheet [#smartsheet_get_sheet]
Get sheet
smartsheet_create_sheet [#smartsheet_create_sheet]
Create sheet
smartsheet_add_rows [#smartsheet_add_rows]
Add rows
smartsheet_update_rows [#smartsheet_update_rows]
Update rows
smartsheet_list_workspaces [#smartsheet_list_workspaces]
List workspaces
smartsheet_list_reports [#smartsheet_list_reports]
List reports
smartsheet_list_attachments [#smartsheet_list_attachments]
List attachments
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Samsung SmartThings Integration
The Samsung SmartThings integration provides access to manage SmartThings locations, rooms, devices, commands, scenes, and rules through the Integrate MCP server.
Installation [#installation]
The Samsung SmartThings integration is included with the SDK:
```typescript
import { smartthingsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Samsung SmartThings OAuth App [#1-create-a-samsung-smartthings-oauth-app]
1. Create an OAuth application for Samsung SmartThings
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Samsung SmartThings integration to your server configuration. The integration automatically reads `SMARTTHINGS_CLIENT_ID` and `SMARTTHINGS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, smartthingsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
smartthingsIntegration({
scopes: ["r:locations:*", "x:locations:*", "r:devices:*", "x:devices:*", "r:scenes:*", "x:scenes:*", "r:rules:*", "x:rules:*"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
smartthingsIntegration({
clientId: process.env.CUSTOM_SMARTTHINGS_ID,
clientSecret: process.env.CUSTOM_SMARTTHINGS_SECRET,
scopes: ["r:locations:*", "x:locations:*", "r:devices:*", "x:devices:*", "r:scenes:*", "x:scenes:*", "r:rules:*", "x:rules:*"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("smartthings");
const result = await client.smartthings.listLocations({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, smartthingsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [smartthingsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `r:locations:*`
* `x:locations:*`
* `r:devices:*`
* `x:devices:*`
* `r:scenes:*`
* `x:scenes:*`
* `r:rules:*`
* `x:rules:*`
Tools [#tools]
smartthings_list_locations [#smartthings_list_locations]
List locations
*No parameters.*
smartthings_get_location [#smartthings_get_location]
Get location
smartthings_list_rooms [#smartthings_list_rooms]
List rooms
smartthings_get_room [#smartthings_get_room]
Get room
smartthings_list_devices [#smartthings_list_devices]
List devices
smartthings_get_device [#smartthings_get_device]
Get device
smartthings_get_device_status [#smartthings_get_device_status]
Get device status
smartthings_execute_device_command [#smartthings_execute_device_command]
Execute device command
smartthings_list_scenes [#smartthings_list_scenes]
List scenes
smartthings_execute_scene [#smartthings_execute_scene]
Execute scene
smartthings_list_rules [#smartthings_list_rules]
List rules
smartthings_get_rule [#smartthings_get_rule]
Get rule
smartthings_create_rule [#smartthings_create_rule]
Create rule
smartthings_update_rule [#smartthings_update_rule]
Update rule
smartthings_delete_rule [#smartthings_delete_rule]
Delete rule
Notes [#notes]
* Category: Lifestyle
* Authentication mode: OAuth
# Snowflake Integration
The Snowflake integration provides access to manage Snowflake submit statement, get statement, cancel statement, list databases, list warehouses through the Integrate MCP server.
Installation [#installation]
The Snowflake integration is included with the SDK:
```typescript
import { snowflakeIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Snowflake OAuth App [#1-create-a-snowflake-oauth-app]
1. Create an OAuth application for Snowflake
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Snowflake integration to your server configuration. The integration automatically reads `SNOWFLAKE_CLIENT_ID` and `SNOWFLAKE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, snowflakeIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
snowflakeIntegration({
scopes: ["session:role-any"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
snowflakeIntegration({
clientId: process.env.CUSTOM_SNOWFLAKE_ID,
clientSecret: process.env.CUSTOM_SNOWFLAKE_SECRET,
scopes: ["session:role-any"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("snowflake");
const result = await client.snowflake.submitStatement({
statement_json: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, snowflakeIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [snowflakeIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `session:role-any`
Tools [#tools]
snowflake_submit_statement [#snowflake_submit_statement]
Submit statement
snowflake_get_statement [#snowflake_get_statement]
Get statement
snowflake_cancel_statement [#snowflake_cancel_statement]
Cancel statement
snowflake_list_databases [#snowflake_list_databases]
List databases
snowflake_list_warehouses [#snowflake_list_warehouses]
List warehouses
Notes [#notes]
* Category: Data & BI
* Authentication mode: OAuth
# Sonos Integration
The Sonos integration provides access to manage Sonos list households, list groups, get playback status, control playback, get group volume through the Integrate MCP server.
Installation [#installation]
The Sonos integration is included with the SDK:
```typescript
import { sonosIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Sonos OAuth App [#1-create-a-sonos-oauth-app]
1. Create an OAuth application for Sonos
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Sonos integration to your server configuration. The integration automatically reads `SONOS_CLIENT_ID` and `SONOS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, sonosIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
sonosIntegration({
scopes: ["playback-control-all"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
sonosIntegration({
clientId: process.env.CUSTOM_SONOS_ID,
clientSecret: process.env.CUSTOM_SONOS_SECRET,
scopes: ["playback-control-all"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("sonos");
const result = await client.sonos.listHouseholds({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, sonosIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [sonosIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `playback-control-all`
Tools [#tools]
sonos_list_households [#sonos_list_households]
List households
*No parameters.*
sonos_list_groups [#sonos_list_groups]
List groups
sonos_get_playback_status [#sonos_get_playback_status]
Get playback status
sonos_control_playback [#sonos_control_playback]
Control playback
sonos_get_group_volume [#sonos_get_group_volume]
Get group volume
sonos_set_group_volume [#sonos_set_group_volume]
Set group volume
Notes [#notes]
* Category: Lifestyle
* Authentication mode: OAuth
# Spotify Integration
The Spotify integration provides access to search Spotify, manage playlists and saved tracks, and control playback through the Integrate MCP server.
Installation [#installation]
The Spotify integration is included with the SDK:
```typescript
import { spotifyIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Spotify OAuth App [#1-create-a-spotify-oauth-app]
1. Create an OAuth application for Spotify
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Spotify integration to your server configuration. The integration automatically reads `SPOTIFY_CLIENT_ID` and `SPOTIFY_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, spotifyIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
spotifyIntegration({
scopes: ["user-read-email", "playlist-read-private", "playlist-modify-private", "playlist-modify-public", "user-library-read", "user-library-modify", "user-read-playback-state", "user-modify-playback-state"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
spotifyIntegration({
clientId: process.env.CUSTOM_SPOTIFY_ID,
clientSecret: process.env.CUSTOM_SPOTIFY_SECRET,
scopes: ["user-read-email", "playlist-read-private", "playlist-modify-private", "playlist-modify-public", "user-library-read", "user-library-modify", "user-read-playback-state", "user-modify-playback-state"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("spotify");
const result = await client.spotify.getCurrentUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, spotifyIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [spotifyIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `user-read-email`
* `playlist-read-private`
* `playlist-modify-private`
* `playlist-modify-public`
* `user-library-read`
* `user-library-modify`
* `user-read-playback-state`
* `user-modify-playback-state`
Tools [#tools]
spotify_get_current_user [#spotify_get_current_user]
Get current user
*No parameters.*
spotify_search [#spotify_search]
Search
spotify_get_track [#spotify_get_track]
Get track
spotify_get_album [#spotify_get_album]
Get album
spotify_list_user_playlists [#spotify_list_user_playlists]
List user playlists
spotify_get_playlist [#spotify_get_playlist]
Get playlist
spotify_create_playlist [#spotify_create_playlist]
Create playlist
spotify_add_playlist_items [#spotify_add_playlist_items]
Add playlist items
spotify_remove_playlist_items [#spotify_remove_playlist_items]
Remove playlist items
spotify_get_saved_tracks [#spotify_get_saved_tracks]
Get saved tracks
spotify_save_tracks [#spotify_save_tracks]
Save tracks
spotify_remove_saved_tracks [#spotify_remove_saved_tracks]
Remove saved tracks
spotify_get_playback_state [#spotify_get_playback_state]
Get playback state
spotify_start_playback [#spotify_start_playback]
Start playback
spotify_pause_playback [#spotify_pause_playback]
Pause playback
Notes [#notes]
* Category: Entertainment
* Authentication mode: OAuth
# Square Integration
The Square integration provides access to manage Square merchants, locations, customers, catalog, orders, payments, refunds, and invoices through the Integrate MCP server.
Installation [#installation]
The Square integration is included with the SDK:
```typescript
import { squareIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Square OAuth App [#1-create-a-square-oauth-app]
1. Create an OAuth application for Square
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Square integration to your server configuration. The integration automatically reads `SQUARE_CLIENT_ID` and `SQUARE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, squareIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
squareIntegration({
scopes: ["MERCHANT_PROFILE_READ", "PAYMENTS_READ", "PAYMENTS_WRITE", "CUSTOMERS_READ", "CUSTOMERS_WRITE", "ORDERS_READ", "ORDERS_WRITE", "ITEMS_READ", "ITEMS_WRITE", "INVOICES_READ", "INVOICES_WRITE"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
squareIntegration({
clientId: process.env.CUSTOM_SQUARE_ID,
clientSecret: process.env.CUSTOM_SQUARE_SECRET,
scopes: ["MERCHANT_PROFILE_READ", "PAYMENTS_READ", "PAYMENTS_WRITE", "CUSTOMERS_READ", "CUSTOMERS_WRITE", "ORDERS_READ", "ORDERS_WRITE", "ITEMS_READ", "ITEMS_WRITE", "INVOICES_READ", "INVOICES_WRITE"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("square");
const result = await client.square.getMerchant({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, squareIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [squareIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `MERCHANT_PROFILE_READ`
* `PAYMENTS_READ`
* `PAYMENTS_WRITE`
* `CUSTOMERS_READ`
* `CUSTOMERS_WRITE`
* `ORDERS_READ`
* `ORDERS_WRITE`
* `ITEMS_READ`
* `ITEMS_WRITE`
* `INVOICES_READ`
* `INVOICES_WRITE`
Tools [#tools]
square_get_merchant [#square_get_merchant]
Get merchant
*No parameters.*
square_list_locations [#square_list_locations]
List locations
*No parameters.*
square_list_customers [#square_list_customers]
List customers
square_get_customer [#square_get_customer]
Get customer
square_create_customer [#square_create_customer]
Create customer
square_update_customer [#square_update_customer]
Update customer
square_delete_customer [#square_delete_customer]
Delete customer
square_search_catalog [#square_search_catalog]
Search catalog
square_retrieve_catalog_object [#square_retrieve_catalog_object]
Retrieve catalog object
square_upsert_catalog_object [#square_upsert_catalog_object]
Upsert catalog object
square_search_orders [#square_search_orders]
Search orders
square_create_order [#square_create_order]
Create order
square_pay_order [#square_pay_order]
Pay order
square_list_payments [#square_list_payments]
List payments
square_get_payment [#square_get_payment]
Get payment
square_create_payment [#square_create_payment]
Create payment
square_list_refunds [#square_list_refunds]
List refunds
square_refund_payment [#square_refund_payment]
Refund payment
square_list_invoices [#square_list_invoices]
List invoices
square_get_invoice [#square_get_invoice]
Get invoice
square_create_invoice [#square_create_invoice]
Create invoice
Notes [#notes]
* Category: Finance
* Authentication mode: OAuth
# Squarespace Integration
The Squarespace integration provides access to manage Squarespace commerce orders, products, inventory, and profiles through the Integrate MCP server.
Installation [#installation]
The Squarespace integration is included with the SDK:
```typescript
import { squarespaceIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Squarespace OAuth App [#1-create-a-squarespace-oauth-app]
1. Create an OAuth application for Squarespace
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Squarespace integration to your server configuration. The integration automatically reads `SQUARESPACE_CLIENT_ID` and `SQUARESPACE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, squarespaceIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
squarespaceIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
squarespaceIntegration({
clientId: process.env.CUSTOM_SQUARESPACE_ID,
clientSecret: process.env.CUSTOM_SQUARESPACE_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("squarespace");
const result = await client.squarespace.listOrders({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, squarespaceIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [squarespaceIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
squarespace_list_orders [#squarespace_list_orders]
List orders
squarespace_get_order [#squarespace_get_order]
Get order
squarespace_list_products [#squarespace_list_products]
List products
squarespace_get_product [#squarespace_get_product]
Get product
squarespace_list_inventory [#squarespace_list_inventory]
List inventory
squarespace_adjust_inventory [#squarespace_adjust_inventory]
Adjust inventory
Notes [#notes]
* Category: Websites & CMS
* Authentication mode: OAuth
# Strava Integration
The Strava integration provides access to manage Strava athletes, activities, routes, clubs, segments, streams, gear, and uploads through the Integrate MCP server.
Installation [#installation]
The Strava integration is included with the SDK:
```typescript
import { stravaIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Strava OAuth App [#1-create-a-strava-oauth-app]
1. Create an OAuth application for Strava
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Strava integration to your server configuration. The integration automatically reads `STRAVA_CLIENT_ID` and `STRAVA_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, stravaIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
stravaIntegration({
scopes: ["read", "profile:read_all", "profile:write", "activity:read", "activity:read_all", "activity:write"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
stravaIntegration({
clientId: process.env.CUSTOM_STRAVA_ID,
clientSecret: process.env.CUSTOM_STRAVA_SECRET,
scopes: ["read", "profile:read_all", "profile:write", "activity:read", "activity:read_all", "activity:write"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("strava");
const result = await client.strava.getLoggedInAthlete({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, stravaIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [stravaIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `read`
* `profile:read_all`
* `profile:write`
* `activity:read`
* `activity:read_all`
* `activity:write`
Tools [#tools]
strava_get_logged_in_athlete [#strava_get_logged_in_athlete]
Get logged in athlete
*No parameters.*
strava_update_logged_in_athlete [#strava_update_logged_in_athlete]
Update logged in athlete
strava_get_athlete_stats [#strava_get_athlete_stats]
Get athlete stats
strava_list_athlete_activities [#strava_list_athlete_activities]
List athlete activities
strava_get_activity [#strava_get_activity]
Get activity
strava_create_activity [#strava_create_activity]
Create activity
strava_update_activity [#strava_update_activity]
Update activity
strava_delete_activity [#strava_delete_activity]
Delete activity
strava_get_activity_streams [#strava_get_activity_streams]
Get activity streams
strava_list_athlete_routes [#strava_list_athlete_routes]
List athlete routes
strava_get_route [#strava_get_route]
Get route
strava_export_route_gpx [#strava_export_route_gpx]
Export route gpx
strava_list_athlete_clubs [#strava_list_athlete_clubs]
List athlete clubs
strava_get_club [#strava_get_club]
Get club
strava_list_club_activities [#strava_list_club_activities]
List club activities
strava_list_club_members [#strava_list_club_members]
List club members
strava_get_segment [#strava_get_segment]
Get segment
strava_explore_segments [#strava_explore_segments]
Explore segments
strava_get_segment_leaderboard [#strava_get_segment_leaderboard]
Get segment leaderboard
strava_list_starred_segments [#strava_list_starred_segments]
List starred segments
strava_star_segment [#strava_star_segment]
Star segment
strava_get_gear [#strava_get_gear]
Get gear
strava_get_upload [#strava_get_upload]
Get upload
strava_create_upload [#strava_create_upload]
Create upload
Notes [#notes]
* Category: Fitness
* Authentication mode: OAuth
# Stripe Integration
The Stripe integration provides access to manage Stripe customers, payments, and subscriptions through the Integrate MCP server.
Installation [#installation]
The Stripe integration is included with the SDK:
```typescript
import { stripeIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Stripe OAuth App [#1-create-a-stripe-oauth-app]
1. Go to [Stripe Connect Settings](https://dashboard.stripe.com/settings/applications)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Stripe integration to your server configuration. The integration automatically reads `STRIPE_CLIENT_ID` and `STRIPE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, stripeIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
stripeIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
stripeIntegration({
clientId: process.env.CUSTOM_STRIPE_ID,
clientSecret: process.env.CUSTOM_STRIPE_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("stripe");
const result = await client.stripe.listCustomers({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, stripeIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [stripeIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
stripe_list_customers [#stripe_list_customers]
List customers
stripe_get_customer [#stripe_get_customer]
Get a specific customer
stripe_create_customer [#stripe_create_customer]
Create a new customer
stripe_update_customer [#stripe_update_customer]
Update an existing customer
stripe_delete_customer [#stripe_delete_customer]
Delete a customer
stripe_search_customers [#stripe_search_customers]
Search customers using Stripe search syntax
stripe_list_payments [#stripe_list_payments]
List payment intents
stripe_get_payment [#stripe_get_payment]
Get a specific payment intent
stripe_create_payment [#stripe_create_payment]
Create a payment intent
stripe_cancel_payment [#stripe_cancel_payment]
Cancel a payment intent
stripe_capture_payment [#stripe_capture_payment]
Capture an authorized payment intent
stripe_list_subscriptions [#stripe_list_subscriptions]
List subscriptions
stripe_get_subscription [#stripe_get_subscription]
Get a subscription by ID
stripe_create_subscription [#stripe_create_subscription]
Create a subscription
stripe_update_subscription [#stripe_update_subscription]
Update a subscription
stripe_cancel_subscription [#stripe_cancel_subscription]
Cancel a subscription
stripe_list_invoices [#stripe_list_invoices]
List invoices
stripe_get_invoice [#stripe_get_invoice]
Get an invoice by ID
stripe_create_invoice [#stripe_create_invoice]
Create an invoice for a customer
stripe_finalize_invoice [#stripe_finalize_invoice]
Finalize a draft invoice
stripe_pay_invoice [#stripe_pay_invoice]
Pay an open invoice immediately
stripe_void_invoice [#stripe_void_invoice]
Void an invoice (cannot be undone)
stripe_list_products [#stripe_list_products]
List products
stripe_get_product [#stripe_get_product]
Get a product by ID
stripe_create_product [#stripe_create_product]
Create a product
stripe_list_prices [#stripe_list_prices]
List prices
stripe_get_price [#stripe_get_price]
Get a price by ID
stripe_create_price [#stripe_create_price]
Create a price for a product
stripe_list_refunds [#stripe_list_refunds]
List refunds
stripe_get_refund [#stripe_get_refund]
Get a refund by ID
stripe_create_refund [#stripe_create_refund]
Create a refund for a payment
stripe_get_balance [#stripe_get_balance]
Get the current Stripe account balance
*No parameters.*
stripe_list_events [#stripe_list_events]
List events from the Stripe event log
stripe_get_event [#stripe_get_event]
Get a specific event by ID
stripe_list_payment_methods [#stripe_list_payment_methods]
List payment methods for a customer
Notes [#notes]
* Category: Finance
* Authentication mode: OAuth
# Supabase Integration
The Supabase integration provides access to manage Supabase organizations, projects, Postgres settings, API keys, secrets, and branches via the Management API through the Integrate MCP server.
Installation [#installation]
The Supabase integration is included with the SDK:
```typescript
import { supabaseIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Supabase to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, supabaseIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
supabaseIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.supabase.getProfile({});
console.log(result);
```
Environment Variables [#environment-variables]
* `SUPABASE_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
supabase_get_profile [#supabase_get_profile]
Get profile
*No parameters.*
supabase_list_organizations [#supabase_list_organizations]
List organizations
*No parameters.*
supabase_get_organization [#supabase_get_organization]
Get organization
supabase_list_organization_projects [#supabase_list_organization_projects]
List organization projects
supabase_list_projects [#supabase_list_projects]
List projects
*No parameters.*
supabase_get_project [#supabase_get_project]
Get project
supabase_create_project [#supabase_create_project]
Create project
supabase_update_project [#supabase_update_project]
Update project
supabase_delete_project [#supabase_delete_project]
Delete project
supabase_list_project_api_keys [#supabase_list_project_api_keys]
List project api keys
supabase_create_project_api_key [#supabase_create_project_api_key]
Create project api key
supabase_delete_project_api_key [#supabase_delete_project_api_key]
Delete project api key
supabase_list_project_secrets [#supabase_list_project_secrets]
List project secrets
supabase_list_project_branches [#supabase_list_project_branches]
List project branches
supabase_get_project_health [#supabase_get_project_health]
Get project health
supabase_get_database_postgres_config [#supabase_get_database_postgres_config]
Get database postgres config
supabase_list_available_regions [#supabase_list_available_regions]
List available regions
*No parameters.*
Notes [#notes]
* Category: Infrastructure
* Authentication mode: API key
# Tableau Integration
The Tableau integration provides access to manage Tableau list sites, list workbooks, get workbook, list views, list datasources through the Integrate MCP server.
Installation [#installation]
The Tableau integration is included with the SDK:
```typescript
import { tableauIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Tableau OAuth App [#1-create-a-tableau-oauth-app]
1. Create an OAuth application for Tableau
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Tableau integration to your server configuration. The integration automatically reads `TABLEAU_CLIENT_ID` and `TABLEAU_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, tableauIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
tableauIntegration({
scopes: ["tableau:content:read", "tableau:content:write", "tableau:users:read"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
tableauIntegration({
clientId: process.env.CUSTOM_TABLEAU_ID,
clientSecret: process.env.CUSTOM_TABLEAU_SECRET,
scopes: ["tableau:content:read", "tableau:content:write", "tableau:users:read"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("tableau");
const result = await client.tableau.listSites({
tableau_base_url: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, tableauIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [tableauIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `tableau:content:read`
* `tableau:content:write`
* `tableau:users:read`
Tools [#tools]
tableau_list_sites [#tableau_list_sites]
List sites
tableau_list_workbooks [#tableau_list_workbooks]
List workbooks
tableau_get_workbook [#tableau_get_workbook]
Get workbook
tableau_list_views [#tableau_list_views]
List views
tableau_list_datasources [#tableau_list_datasources]
List datasources
tableau_run_query_view_data [#tableau_run_query_view_data]
Run query view data
Notes [#notes]
* Category: Data & BI
* Authentication mode: OAuth
# Microsoft Teams Integration
The Microsoft Teams integration provides access to collaborate in Teams channels and chats using Microsoft Graph β teams, channels, messages, and profile. through the Integrate MCP server.
Installation [#installation]
The Microsoft Teams integration is included with the SDK:
```typescript
import { teamsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Microsoft Teams OAuth App [#1-create-a-microsoft-teams-oauth-app]
1. Go to [Azure Portal β App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Microsoft Teams integration to your server configuration. The integration automatically reads `TEAMS_CLIENT_ID` and `TEAMS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, teamsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
teamsIntegration({
scopes: ["offline_access", "User.Read", "Team.ReadBasic.All", "Channel.ReadBasic.All", "ChannelMessage.Read.All", "ChannelMessage.Send", "Chat.Read", "Chat.ReadWrite"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
teamsIntegration({
clientId: process.env.CUSTOM_TEAMS_ID,
clientSecret: process.env.CUSTOM_TEAMS_SECRET,
scopes: ["offline_access", "User.Read", "Team.ReadBasic.All", "Channel.ReadBasic.All", "ChannelMessage.Read.All", "ChannelMessage.Send", "Chat.Read", "Chat.ReadWrite"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("teams");
const result = await client.teams.getChannel({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, teamsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [teamsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `offline_access`
* `User.Read`
* `Team.ReadBasic.All`
* `Channel.ReadBasic.All`
* `ChannelMessage.Read.All`
* `ChannelMessage.Send`
* `Chat.Read`
* `Chat.ReadWrite`
Tools [#tools]
teams_get_channel [#teams_get_channel]
Get channel
teams_get_chat [#teams_get_chat]
Get chat
teams_get_profile [#teams_get_profile]
Get profile
teams_get_team [#teams_get_team]
Get team
teams_list_channel_messages [#teams_list_channel_messages]
List channel messages
teams_list_channels [#teams_list_channels]
List channels
teams_list_chat_messages [#teams_list_chat_messages]
List chat messages
teams_list_chats [#teams_list_chats]
List chats
teams_list_teams [#teams_list_teams]
List teams
teams_reply_channel_message [#teams_reply_channel_message]
Reply channel message
teams_send_channel_message [#teams_send_channel_message]
Send channel message
teams_send_chat_message [#teams_send_chat_message]
Send chat message
Notes [#notes]
* Category: Communication
* Authentication mode: OAuth
# Telegram Integration
The Telegram integration provides access to use Telegram as an actual user account via MTProto sessions, not the Bot API through the Integrate MCP server.
Installation [#installation]
The Telegram integration is included with the SDK:
```typescript
import { telegramIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Telegram to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, telegramIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
telegramIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.telegram.authSendCode({
phone_number: "value",
});
console.log(result);
```
Environment Variables [#environment-variables]
* `TELEGRAM_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
telegram_auth_send_code [#telegram_auth_send_code]
Auth send code
telegram_auth_sign_in [#telegram_auth_sign_in]
Auth sign in
telegram_auth_check_password [#telegram_auth_check_password]
Auth check password
telegram_get_me [#telegram_get_me]
Get me
telegram_resolve_username [#telegram_resolve_username]
Resolve username
telegram_list_dialogs [#telegram_list_dialogs]
List dialogs
telegram_get_history [#telegram_get_history]
Get history
telegram_search_messages [#telegram_search_messages]
Search messages
telegram_send_message [#telegram_send_message]
Send message
Notes [#notes]
* Category: Communication
* Authentication mode: API key
# Tesla Integration
The Tesla integration provides access to manage Tesla list vehicles, get vehicle, wake vehicle, send vehicle command, list energy sites through the Integrate MCP server.
Installation [#installation]
The Tesla integration is included with the SDK:
```typescript
import { teslaIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Tesla OAuth App [#1-create-a-tesla-oauth-app]
1. Create an OAuth application for Tesla
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Tesla integration to your server configuration. The integration automatically reads `TESLA_CLIENT_ID` and `TESLA_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, teslaIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
teslaIntegration({
scopes: ["openid", "offline_access", "vehicle_device_data", "vehicle_cmds", "energy_device_data", "energy_cmds"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
teslaIntegration({
clientId: process.env.CUSTOM_TESLA_ID,
clientSecret: process.env.CUSTOM_TESLA_SECRET,
scopes: ["openid", "offline_access", "vehicle_device_data", "vehicle_cmds", "energy_device_data", "energy_cmds"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("tesla");
const result = await client.tesla.listVehicles({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, teslaIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [teslaIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `openid`
* `offline_access`
* `vehicle_device_data`
* `vehicle_cmds`
* `energy_device_data`
* `energy_cmds`
Tools [#tools]
tesla_list_vehicles [#tesla_list_vehicles]
List vehicles
*No parameters.*
tesla_get_vehicle [#tesla_get_vehicle]
Get vehicle
tesla_wake_vehicle [#tesla_wake_vehicle]
Wake vehicle
tesla_send_vehicle_command [#tesla_send_vehicle_command]
Send vehicle command
tesla_list_energy_sites [#tesla_list_energy_sites]
List energy sites
*No parameters.*
Notes [#notes]
* Category: Lifestyle
* Authentication mode: OAuth
# Threads Integration
The Threads integration provides access to publish Threads posts and manage media, replies, conversations, and keyword search through the Integrate MCP server.
Installation [#installation]
The Threads integration is included with the SDK:
```typescript
import { threadsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Threads OAuth App [#1-create-a-threads-oauth-app]
1. Go to [Threads Developer Portal](https://threads.net)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Threads integration to your server configuration. The integration automatically reads `THREADS_CLIENT_ID` and `THREADS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, threadsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
threadsIntegration({
scopes: ["threads_basic", "threads_content_publish", "threads_read_replies", "threads_manage_replies", "threads_manage_insights", "threads_keyword_search", "threads_profile_discovery", "threads_manage_mentions"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
threadsIntegration({
clientId: process.env.CUSTOM_THREADS_ID,
clientSecret: process.env.CUSTOM_THREADS_SECRET,
scopes: ["threads_basic", "threads_content_publish", "threads_read_replies", "threads_manage_replies", "threads_manage_insights", "threads_keyword_search", "threads_profile_discovery", "threads_manage_mentions"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("threads");
const result = await client.threads.getMe({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, threadsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [threadsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `threads_basic`
* `threads_content_publish`
* `threads_read_replies`
* `threads_manage_replies`
* `threads_manage_insights`
* `threads_keyword_search`
* `threads_profile_discovery`
* `threads_manage_mentions`
Tools [#tools]
threads_get_me [#threads_get_me]
Get me
threads_list_user_media [#threads_list_user_media]
List user media
threads_get_media [#threads_get_media]
Get media
threads_keyword_search [#threads_keyword_search]
Keyword search
threads_create_media_container [#threads_create_media_container]
Create media container
threads_publish_media_container [#threads_publish_media_container]
Publish media container
threads_get_container_status [#threads_get_container_status]
Get container status
threads_list_replies [#threads_list_replies]
List replies
threads_get_conversation [#threads_get_conversation]
Get conversation
threads_manage_reply [#threads_manage_reply]
Manage reply
threads_repost [#threads_repost]
Repost
threads_delete_media [#threads_delete_media]
Delete media
Notes [#notes]
* Category: Social Media
* Authentication mode: OAuth
# TikTok Integration
The TikTok integration provides access to read TikTok user profile data and user-authorized video metadata through the Integrate MCP server.
Installation [#installation]
The TikTok integration is included with the SDK:
```typescript
import { tiktokIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a TikTok OAuth App [#1-create-a-tiktok-oauth-app]
1. Go to [Tiktok Developer Portal](https://www.tiktok.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the TikTok integration to your server configuration. The integration automatically reads `TIKTOK_CLIENT_ID` and `TIKTOK_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, tiktokIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
tiktokIntegration({
scopes: ["user.info.basic", "video.list"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
tiktokIntegration({
clientId: process.env.CUSTOM_TIKTOK_ID,
clientSecret: process.env.CUSTOM_TIKTOK_SECRET,
scopes: ["user.info.basic", "video.list"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("tiktok");
const result = await client.tiktok.getUserInfo({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, tiktokIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [tiktokIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `user.info.basic`
* `video.list`
Tools [#tools]
tiktok_get_user_info [#tiktok_get_user_info]
Get user info
tiktok_list_videos [#tiktok_list_videos]
List videos
tiktok_query_videos [#tiktok_query_videos]
Query videos
Notes [#notes]
* Category: Entertainment
* Authentication mode: OAuth
# TikTok Business Integration
The TikTok Business integration provides access to manage TikTok Business list advertisers, list campaigns, create campaign, list adgroups, list ads through the Integrate MCP server.
Installation [#installation]
The TikTok Business integration is included with the SDK:
```typescript
import { tiktokBusinessIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a TikTok Business OAuth App [#1-create-a-tiktok-business-oauth-app]
1. Create an OAuth application for TikTok Business
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the TikTok Business integration to your server configuration. The integration automatically reads `TIKTOK_BUSINESS_CLIENT_ID` and `TIKTOK_BUSINESS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, tiktokBusinessIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
tiktokBusinessIntegration({
scopes: ["user.info.basic", "advertiser.read", "campaign.read", "campaign.write", "adgroup.read", "adgroup.write", "ad.read", "ad.write", "report.read"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
tiktokBusinessIntegration({
clientId: process.env.CUSTOM_TIKTOK_BUSINESS_ID,
clientSecret: process.env.CUSTOM_TIKTOK_BUSINESS_SECRET,
scopes: ["user.info.basic", "advertiser.read", "campaign.read", "campaign.write", "adgroup.read", "adgroup.write", "ad.read", "ad.write", "report.read"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("tiktok_business");
const result = await client.tiktok_business.listAdvertisers({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, tiktokBusinessIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [tiktokBusinessIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `user.info.basic`
* `advertiser.read`
* `campaign.read`
* `campaign.write`
* `adgroup.read`
* `adgroup.write`
* `ad.read`
* `ad.write`
* `report.read`
Tools [#tools]
tiktok_business_list_advertisers [#tiktok_business_list_advertisers]
Business list advertisers
*No parameters.*
tiktok_business_list_campaigns [#tiktok_business_list_campaigns]
Business list campaigns
tiktok_business_create_campaign [#tiktok_business_create_campaign]
Business create campaign
tiktok_business_list_adgroups [#tiktok_business_list_adgroups]
Business list adgroups
tiktok_business_list_ads [#tiktok_business_list_ads]
Business list ads
tiktok_business_run_report [#tiktok_business_run_report]
Business run report
Notes [#notes]
* Category: Marketing
* Authentication mode: OAuth
# Tink Integration
The Tink integration provides access to manage Tink get user, list accounts, get account, list transactions, list credentials through the Integrate MCP server.
Installation [#installation]
The Tink integration is included with the SDK:
```typescript
import { tinkIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Tink OAuth App [#1-create-a-tink-oauth-app]
1. Create an OAuth application for Tink
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Tink integration to your server configuration. The integration automatically reads `TINK_CLIENT_ID` and `TINK_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, tinkIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
tinkIntegration({
scopes: ["accounts:read", "transactions:read", "user:read", "credentials:read"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
tinkIntegration({
clientId: process.env.CUSTOM_TINK_ID,
clientSecret: process.env.CUSTOM_TINK_SECRET,
scopes: ["accounts:read", "transactions:read", "user:read", "credentials:read"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("tink");
const result = await client.tink.getUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, tinkIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [tinkIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `accounts:read`
* `transactions:read`
* `user:read`
* `credentials:read`
Tools [#tools]
tink_get_user [#tink_get_user]
Get user
*No parameters.*
tink_list_accounts [#tink_list_accounts]
List accounts
*No parameters.*
tink_get_account [#tink_get_account]
Get account
tink_list_transactions [#tink_list_transactions]
List transactions
tink_list_credentials [#tink_list_credentials]
List credentials
*No parameters.*
tink_refresh_credentials [#tink_refresh_credentials]
Refresh credentials
Notes [#notes]
* Category: Banking
* Authentication mode: OAuth
# tldraw Integration
The tldraw integration provides access to create and manage tldraw collaborative whiteboards through the Integrate MCP server.
Installation [#installation]
The tldraw integration is included with the SDK:
```typescript
import { tldrawIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add tldraw to your server configuration:
```typescript
import { createMCPServer, tldrawIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
tldrawIntegration(),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
// Use client.tldraw methods after connecting
```
Configuration Options [#configuration-options]
Tools [#tools]
tldraw_unfurl_url [#tldraw_unfurl_url]
Unfurl url
*No parameters.*
tldraw_create_room_snapshot [#tldraw_create_room_snapshot]
Create room snapshot
*No parameters.*
tldraw_get_room_snapshot [#tldraw_get_room_snapshot]
Get room snapshot
*No parameters.*
tldraw_get_published_snapshot [#tldraw_get_published_snapshot]
Get published snapshot
*No parameters.*
tldraw_get_readonly_slug [#tldraw_get_readonly_slug]
Get readonly slug
*No parameters.*
Notes [#notes]
* Category: Productivity
* Authentication mode: None
# Todoist Integration
The Todoist integration provides access to manage Todoist tasks, projects, and labels through the Integrate MCP server.
Installation [#installation]
The Todoist integration is included with the SDK:
```typescript
import { todoistIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Todoist OAuth App [#1-create-a-todoist-oauth-app]
1. Go to [Todoist App Console](https://developer.todoist.com/appconsole.html)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Todoist integration to your server configuration. The integration automatically reads `TODOIST_CLIENT_ID` and `TODOIST_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, todoistIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
todoistIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
todoistIntegration({
clientId: process.env.CUSTOM_TODOIST_ID,
clientSecret: process.env.CUSTOM_TODOIST_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("todoist");
const result = await client.todoist.listProjects({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, todoistIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [todoistIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
todoist_list_projects [#todoist_list_projects]
List all projects
*No parameters.*
todoist_get_project [#todoist_get_project]
Get details of a specific project
todoist_create_project [#todoist_create_project]
Create a new project
todoist_update_project [#todoist_update_project]
Update an existing project
todoist_delete_project [#todoist_delete_project]
Delete a project
todoist_archive_project [#todoist_archive_project]
Archive a project
todoist_list_tasks [#todoist_list_tasks]
List active tasks with optional filters
todoist_get_task [#todoist_get_task]
Get details of a specific task
todoist_create_task [#todoist_create_task]
Create a new task
todoist_update_task [#todoist_update_task]
Update an existing task
todoist_complete_task [#todoist_complete_task]
Mark a task as complete
todoist_delete_task [#todoist_delete_task]
Delete a task permanently
todoist_reopen_task [#todoist_reopen_task]
Reopen a completed task
todoist_move_task [#todoist_move_task]
Move a task to a different project, section, or parent
todoist_quick_add_task [#todoist_quick_add_task]
Add a task using natural language
todoist_get_completed_tasks [#todoist_get_completed_tasks]
Get completed tasks
todoist_filter_tasks [#todoist_filter_tasks]
Get tasks matching a Todoist filter expression
todoist_list_sections [#todoist_list_sections]
List sections, optionally filtered by project
todoist_create_section [#todoist_create_section]
Create a new section in a project
todoist_get_section [#todoist_get_section]
Get details of a specific section
todoist_update_section [#todoist_update_section]
Rename a section
todoist_delete_section [#todoist_delete_section]
Delete a section (and all tasks in it)
todoist_list_comments [#todoist_list_comments]
List comments on a task or project
todoist_create_comment [#todoist_create_comment]
Add a comment to a task or project
todoist_get_comment [#todoist_get_comment]
Get details of a specific comment
todoist_update_comment [#todoist_update_comment]
Update a comment's text
todoist_delete_comment [#todoist_delete_comment]
Delete a comment
todoist_list_labels [#todoist_list_labels]
List all personal labels
*No parameters.*
todoist_create_label [#todoist_create_label]
Create a new label
todoist_update_label [#todoist_update_label]
Update a label
todoist_delete_label [#todoist_delete_label]
Delete a label
todoist_list_reminders [#todoist_list_reminders]
List all reminders
*No parameters.*
todoist_create_reminder [#todoist_create_reminder]
Create a reminder for a task
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Trello Integration
The Trello integration provides access to manage Trello boards, lists, cards, comments, and search through the Integrate MCP server.
Installation [#installation]
The Trello integration is included with the SDK:
```typescript
import { trelloIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Trello to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, trelloIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
trelloIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.trello.getMember({});
console.log(result);
```
Environment Variables [#environment-variables]
* `TRELLO_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
trello_get_member [#trello_get_member]
Get member
trello_list_boards [#trello_list_boards]
List boards
trello_get_board [#trello_get_board]
Get board
trello_list_lists [#trello_list_lists]
List lists
trello_get_list [#trello_get_list]
Get list
trello_list_cards [#trello_list_cards]
List cards
trello_get_card [#trello_get_card]
Get card
trello_create_card [#trello_create_card]
Create card
trello_update_card [#trello_update_card]
Update card
trello_delete_card [#trello_delete_card]
Delete card
trello_add_card_comment [#trello_add_card_comment]
Add card comment
trello_search [#trello_search]
Search
Notes [#notes]
* Category: Productivity
* Authentication mode: API key
# TrueLayer Integration
The TrueLayer integration provides access to manage TrueLayer get me, list accounts, get account, get balance, list transactions through the Integrate MCP server.
Installation [#installation]
The TrueLayer integration is included with the SDK:
```typescript
import { truelayerIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a TrueLayer OAuth App [#1-create-a-truelayer-oauth-app]
1. Create an OAuth application for TrueLayer
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the TrueLayer integration to your server configuration. The integration automatically reads `TRUELAYER_CLIENT_ID` and `TRUELAYER_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, truelayerIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
truelayerIntegration({
scopes: ["info", "accounts", "balance", "cards", "transactions", "direct_debits", "standing_orders", "offline_access"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
truelayerIntegration({
clientId: process.env.CUSTOM_TRUELAYER_ID,
clientSecret: process.env.CUSTOM_TRUELAYER_SECRET,
scopes: ["info", "accounts", "balance", "cards", "transactions", "direct_debits", "standing_orders", "offline_access"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("truelayer");
const result = await client.truelayer.getMe({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, truelayerIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [truelayerIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `info`
* `accounts`
* `balance`
* `cards`
* `transactions`
* `direct_debits`
* `standing_orders`
* `offline_access`
Tools [#tools]
truelayer_get_me [#truelayer_get_me]
Get me
*No parameters.*
truelayer_list_accounts [#truelayer_list_accounts]
List accounts
*No parameters.*
truelayer_get_account [#truelayer_get_account]
Get account
truelayer_get_balance [#truelayer_get_balance]
Get balance
truelayer_list_transactions [#truelayer_list_transactions]
List transactions
truelayer_list_cards [#truelayer_list_cards]
List cards
*No parameters.*
Notes [#notes]
* Category: Banking
* Authentication mode: OAuth
# Tuya Integration
The Tuya integration provides access to manage Tuya list devices, get device, get device status, send device commands, list scenes through the Integrate MCP server.
Installation [#installation]
The Tuya integration is included with the SDK:
```typescript
import { tuyaIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Tuya OAuth App [#1-create-a-tuya-oauth-app]
1. Create an OAuth application for Tuya
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Tuya integration to your server configuration. The integration automatically reads `TUYA_CLIENT_ID` and `TUYA_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, tuyaIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
tuyaIntegration({
scopes: ["device:read", "device:write", "home:read", "scene:read", "scene:write"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
tuyaIntegration({
clientId: process.env.CUSTOM_TUYA_ID,
clientSecret: process.env.CUSTOM_TUYA_SECRET,
scopes: ["device:read", "device:write", "home:read", "scene:read", "scene:write"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("tuya");
const result = await client.tuya.listDevices({
user_id: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, tuyaIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [tuyaIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `device:read`
* `device:write`
* `home:read`
* `scene:read`
* `scene:write`
Tools [#tools]
tuya_list_devices [#tuya_list_devices]
List devices
tuya_get_device [#tuya_get_device]
Get device
tuya_get_device_status [#tuya_get_device_status]
Get device status
tuya_send_device_commands [#tuya_send_device_commands]
Send device commands
tuya_list_scenes [#tuya_list_scenes]
List scenes
Notes [#notes]
* Category: Lifestyle
* Authentication mode: OAuth
# Twitch Integration
The Twitch integration provides access to manage Twitch users, streams, channels, clips, videos, games, follows, and subscriptions through the Integrate MCP server.
Installation [#installation]
The Twitch integration is included with the SDK:
```typescript
import { twitchIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Twitch OAuth App [#1-create-a-twitch-oauth-app]
1. Create an OAuth application for Twitch
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Twitch integration to your server configuration. The integration automatically reads `TWITCH_CLIENT_ID` and `TWITCH_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, twitchIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
twitchIntegration({
scopes: ["user:read:email", "channel:read:subscriptions", "clips:edit", "channel:manage:broadcast", "user:read:follows"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
twitchIntegration({
clientId: process.env.CUSTOM_TWITCH_ID,
clientSecret: process.env.CUSTOM_TWITCH_SECRET,
scopes: ["user:read:email", "channel:read:subscriptions", "clips:edit", "channel:manage:broadcast", "user:read:follows"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("twitch");
const result = await client.twitch.getUsers({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, twitchIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [twitchIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `user:read:email`
* `channel:read:subscriptions`
* `clips:edit`
* `channel:manage:broadcast`
* `user:read:follows`
Tools [#tools]
twitch_get_users [#twitch_get_users]
Get users
twitch_get_streams [#twitch_get_streams]
Get streams
twitch_get_channels [#twitch_get_channels]
Get channels
twitch_modify_channel [#twitch_modify_channel]
Modify channel
twitch_create_clip [#twitch_create_clip]
Create clip
twitch_get_videos [#twitch_get_videos]
Get videos
twitch_get_games [#twitch_get_games]
Get games
twitch_get_channel_followers [#twitch_get_channel_followers]
Get channel followers
twitch_get_broadcaster_subscriptions [#twitch_get_broadcaster_subscriptions]
Get broadcaster subscriptions
Notes [#notes]
* Category: Entertainment
* Authentication mode: OAuth
# Typeform Integration
The Typeform integration provides access to manage Typeform workspaces, forms, and responses through the Integrate MCP server.
Installation [#installation]
The Typeform integration is included with the SDK:
```typescript
import { typeformIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Typeform OAuth App [#1-create-a-typeform-oauth-app]
1. Go to [Api Developer Portal](https://api.typeform.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Typeform integration to your server configuration. The integration automatically reads `TYPEFORM_CLIENT_ID` and `TYPEFORM_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, typeformIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
typeformIntegration({
scopes: ["offline", "accounts:read", "forms:read", "forms:write", "responses:read", "workspaces:read"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
typeformIntegration({
clientId: process.env.CUSTOM_TYPEFORM_ID,
clientSecret: process.env.CUSTOM_TYPEFORM_SECRET,
scopes: ["offline", "accounts:read", "forms:read", "forms:write", "responses:read", "workspaces:read"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("typeform");
const result = await client.typeform.getMe({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, typeformIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [typeformIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `offline`
* `accounts:read`
* `forms:read`
* `forms:write`
* `responses:read`
* `workspaces:read`
Tools [#tools]
typeform_get_me [#typeform_get_me]
Get me
*No parameters.*
typeform_list_workspaces [#typeform_list_workspaces]
List workspaces
typeform_get_workspace [#typeform_get_workspace]
Get workspace
typeform_list_forms [#typeform_list_forms]
List forms
typeform_get_form [#typeform_get_form]
Get form
typeform_create_form [#typeform_create_form]
Create form
typeform_update_form [#typeform_update_form]
Update form
typeform_delete_form [#typeform_delete_form]
Delete form
typeform_list_responses [#typeform_list_responses]
List responses
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Uber Integration
The Uber integration provides access to manage Uber get profile, list products, estimate price, estimate time, list requests through the Integrate MCP server.
Installation [#installation]
The Uber integration is included with the SDK:
```typescript
import { uberIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Uber OAuth App [#1-create-an-uber-oauth-app]
1. Create an OAuth application for Uber
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Uber integration to your server configuration. The integration automatically reads `UBER_CLIENT_ID` and `UBER_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, uberIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
uberIntegration({
scopes: ["profile", "request", "history", "places"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
uberIntegration({
clientId: process.env.CUSTOM_UBER_ID,
clientSecret: process.env.CUSTOM_UBER_SECRET,
scopes: ["profile", "request", "history", "places"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("uber");
const result = await client.uber.getProfile({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, uberIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [uberIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `profile`
* `request`
* `history`
* `places`
Tools [#tools]
uber_get_profile [#uber_get_profile]
Get profile
*No parameters.*
uber_list_products [#uber_list_products]
List products
uber_estimate_price [#uber_estimate_price]
Estimate price
uber_estimate_time [#uber_estimate_time]
Estimate time
uber_list_requests [#uber_list_requests]
List requests
uber_create_request [#uber_create_request]
Create request
Notes [#notes]
* Category: Travel
* Authentication mode: OAuth
# Uber Eats Integration
The Uber Eats integration provides access to manage Uber Eats list stores, get store, list orders, get order, update order status through the Integrate MCP server.
Installation [#installation]
The Uber Eats integration is included with the SDK:
```typescript
import { uberEatsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Uber Eats OAuth App [#1-create-an-uber-eats-oauth-app]
1. Create an OAuth application for Uber Eats
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Uber Eats integration to your server configuration. The integration automatically reads `UBER_EATS_CLIENT_ID` and `UBER_EATS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, uberEatsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
uberEatsIntegration({
scopes: ["eats.store", "eats.order", "eats.report"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
uberEatsIntegration({
clientId: process.env.CUSTOM_UBER_EATS_ID,
clientSecret: process.env.CUSTOM_UBER_EATS_SECRET,
scopes: ["eats.store", "eats.order", "eats.report"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("uber_eats");
const result = await client.uber_eats.listStores({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, uberEatsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [uberEatsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `eats.store`
* `eats.order`
* `eats.report`
Tools [#tools]
uber_eats_list_stores [#uber_eats_list_stores]
Eats list stores
uber_eats_get_store [#uber_eats_get_store]
Eats get store
uber_eats_list_orders [#uber_eats_list_orders]
Eats list orders
uber_eats_get_order [#uber_eats_get_order]
Eats get order
uber_eats_update_order_status [#uber_eats_update_order_status]
Eats update order status
uber_eats_get_menu [#uber_eats_get_menu]
Eats get menu
Notes [#notes]
* Category: Food
* Authentication mode: OAuth
# Universe Integration
The Universe integration provides access to manage Universe get user, list events, get event, create event, list orders through the Integrate MCP server.
Installation [#installation]
The Universe integration is included with the SDK:
```typescript
import { universeIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an Universe OAuth App [#1-create-an-universe-oauth-app]
1. Create an OAuth application for Universe
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Universe integration to your server configuration. The integration automatically reads `UNIVERSE_CLIENT_ID` and `UNIVERSE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, universeIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
universeIntegration({
scopes: ["read", "write"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
universeIntegration({
clientId: process.env.CUSTOM_UNIVERSE_ID,
clientSecret: process.env.CUSTOM_UNIVERSE_SECRET,
scopes: ["read", "write"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("universe");
const result = await client.universe.getUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, universeIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [universeIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `read`
* `write`
Tools [#tools]
universe_get_user [#universe_get_user]
Get user
*No parameters.*
universe_list_events [#universe_list_events]
List events
universe_get_event [#universe_get_event]
Get event
universe_create_event [#universe_create_event]
Create event
universe_list_orders [#universe_list_orders]
List orders
universe_list_attendees [#universe_list_attendees]
List attendees
Notes [#notes]
* Category: Events & Ticketing
* Authentication mode: OAuth
# UPS Integration
The UPS integration provides access to manage UPS track shipment, rate shipment, create shipment, void shipment, validate address through the Integrate MCP server.
Installation [#installation]
The UPS integration is included with the SDK:
```typescript
import { upsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create an UPS OAuth App [#1-create-an-ups-oauth-app]
1. Create an OAuth application for UPS
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the UPS integration to your server configuration. The integration automatically reads `UPS_CLIENT_ID` and `UPS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, upsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
upsIntegration({
scopes: ["shipments", "tracking", "rating", "address_validation"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
upsIntegration({
clientId: process.env.CUSTOM_UPS_ID,
clientSecret: process.env.CUSTOM_UPS_SECRET,
scopes: ["shipments", "tracking", "rating", "address_validation"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("ups");
const result = await client.ups.trackShipment({
tracking_number: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, upsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [upsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `shipments`
* `tracking`
* `rating`
* `address_validation`
Tools [#tools]
ups_track_shipment [#ups_track_shipment]
Track shipment
ups_rate_shipment [#ups_rate_shipment]
Rate shipment
ups_create_shipment [#ups_create_shipment]
Create shipment
ups_void_shipment [#ups_void_shipment]
Void shipment
ups_validate_address [#ups_validate_address]
Validate address
Notes [#notes]
* Category: Shipping & Logistics
* Authentication mode: OAuth
# Upstash Integration
The Upstash integration provides access to serverless Redis (REST), QStash messaging, and HTTP APIs through the Integrate MCP server.
Installation [#installation]
The Upstash integration is included with the SDK:
```typescript
import { upstashIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Upstash to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, upstashIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
upstashIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.upstash.redisRun({});
console.log(result);
```
Environment Variables [#environment-variables]
* `UPSTASH_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
upstash_redis_run [#upstash_redis_run]
Redis run
upstash_redis_get [#upstash_redis_get]
Redis get
upstash_redis_set [#upstash_redis_set]
Redis set
upstash_redis_del [#upstash_redis_del]
Redis del
upstash_qstash_publish [#upstash_qstash_publish]
Qstash publish
Notes [#notes]
* Category: Infrastructure
* Authentication mode: API key
# Vercel Integration
The Vercel integration provides access to manage Vercel projects, deployments, and domains through the Integrate MCP server.
Installation [#installation]
The Vercel integration is included with the SDK:
```typescript
import { vercelIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Vercel OAuth App [#1-create-a-vercel-oauth-app]
1. Go to [Vercel Integrations](https://vercel.com/dashboard/integrations)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Vercel integration to your server configuration. The integration automatically reads `VERCEL_CLIENT_ID` and `VERCEL_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, vercelIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
vercelIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
vercelIntegration({
clientId: process.env.CUSTOM_VERCEL_ID,
clientSecret: process.env.CUSTOM_VERCEL_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("vercel");
const result = await client.vercel.listProjects({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, vercelIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [vercelIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
vercel_list_projects [#vercel_list_projects]
List projects in Vercel
vercel_get_project [#vercel_get_project]
Get a specific project
vercel_create_project [#vercel_create_project]
Create a new project
vercel_update_project [#vercel_update_project]
Update an existing project
vercel_delete_project [#vercel_delete_project]
Delete a project
vercel_list_deployments [#vercel_list_deployments]
List deployments
vercel_get_deployment [#vercel_get_deployment]
Get a specific deployment
vercel_create_deployment [#vercel_create_deployment]
Create a new deployment
vercel_cancel_deployment [#vercel_cancel_deployment]
Cancel a deployment
vercel_delete_deployment [#vercel_delete_deployment]
Delete a deployment
vercel_promote_deployment [#vercel_promote_deployment]
Promote a deployment to production
vercel_get_deployment_logs [#vercel_get_deployment_logs]
Get deployment logs
vercel_list_domains [#vercel_list_domains]
List domains for a project
vercel_add_domain [#vercel_add_domain]
Add a domain to a project
vercel_remove_domain [#vercel_remove_domain]
Remove a domain from a project
vercel_get_domain_config [#vercel_get_domain_config]
Get domain configuration
vercel_list_env_vars [#vercel_list_env_vars]
List environment variables for a project
vercel_create_env_var [#vercel_create_env_var]
Create an environment variable
vercel_delete_env_var [#vercel_delete_env_var]
Delete an environment variable
vercel_list_dns_records [#vercel_list_dns_records]
List DNS records for a domain
vercel_create_dns_record [#vercel_create_dns_record]
Create a DNS record
Notes [#notes]
* Category: Infrastructure
* Authentication mode: OAuth
# Webflow Integration
The Webflow integration provides access to manage Webflow sites, CMS collections, pages, forms, and publishing through the Integrate MCP server.
Installation [#installation]
The Webflow integration is included with the SDK:
```typescript
import { webflowIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Webflow OAuth App [#1-create-a-webflow-oauth-app]
1. Go to [Webflow Developer Portal](https://webflow.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Webflow integration to your server configuration. The integration automatically reads `WEBFLOW_CLIENT_ID` and `WEBFLOW_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, webflowIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
webflowIntegration({
scopes: ["authorized_user:read", "assets:read", "assets:write", "cms:read", "cms:write", "custom_code:read", "custom_code:write", "forms:read", "forms:write", "pages:read", "pages:write", "sites:read", "sites:write"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
webflowIntegration({
clientId: process.env.CUSTOM_WEBFLOW_ID,
clientSecret: process.env.CUSTOM_WEBFLOW_SECRET,
scopes: ["authorized_user:read", "assets:read", "assets:write", "cms:read", "cms:write", "custom_code:read", "custom_code:write", "forms:read", "forms:write", "pages:read", "pages:write", "sites:read", "sites:write"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("webflow");
const result = await client.webflow.tokenIntrospect({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, webflowIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [webflowIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `authorized_user:read`
* `assets:read`
* `assets:write`
* `cms:read`
* `cms:write`
* `custom_code:read`
* `custom_code:write`
* `forms:read`
* `forms:write`
* `pages:read`
* `pages:write`
* `sites:read`
* `sites:write`
Tools [#tools]
webflow_token_introspect [#webflow_token_introspect]
Token introspect
*No parameters.*
webflow_get_authorized_user [#webflow_get_authorized_user]
Get authorized user
*No parameters.*
webflow_list_sites [#webflow_list_sites]
List sites
*No parameters.*
webflow_get_site [#webflow_get_site]
Get site
webflow_get_site_custom_domains [#webflow_get_site_custom_domains]
Get site custom domains
webflow_publish_site [#webflow_publish_site]
Publish site
webflow_list_site_pages [#webflow_list_site_pages]
List site pages
webflow_list_site_collections [#webflow_list_site_collections]
List site collections
webflow_get_collection [#webflow_get_collection]
Get collection
webflow_list_collection_items [#webflow_list_collection_items]
List collection items
webflow_list_live_collection_items [#webflow_list_live_collection_items]
List live collection items
webflow_get_collection_item [#webflow_get_collection_item]
Get collection item
webflow_create_collection_items [#webflow_create_collection_items]
Create collection items
webflow_update_collection_items [#webflow_update_collection_items]
Update collection items
webflow_delete_collection_items [#webflow_delete_collection_items]
Delete collection items
webflow_publish_collection_items [#webflow_publish_collection_items]
Publish collection items
webflow_list_site_forms [#webflow_list_site_forms]
List site forms
webflow_list_site_webhooks [#webflow_list_site_webhooks]
List site webhooks
Notes [#notes]
* Category: Websites & CMS
* Authentication mode: OAuth
# WhatsApp Business Integration
The WhatsApp Business integration provides access to send WhatsApp messages and templates through the Integrate MCP server.
Installation [#installation]
The WhatsApp Business integration is included with the SDK:
```typescript
import { whatsappIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a WhatsApp Business OAuth App [#1-create-a-whatsapp-business-oauth-app]
1. Go to [Meta for Developers](https://developers.facebook.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the WhatsApp Business integration to your server configuration. The integration automatically reads `WHATSAPP_CLIENT_ID` and `WHATSAPP_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, whatsappIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
whatsappIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
whatsappIntegration({
clientId: process.env.CUSTOM_WHATSAPP_ID,
clientSecret: process.env.CUSTOM_WHATSAPP_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("whatsapp");
const result = await client.whatsapp.sendMessage({
phone_number_id: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, whatsappIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [whatsappIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
whatsapp_send_message [#whatsapp_send_message]
Send a plain text message
whatsapp_reply_message [#whatsapp_reply_message]
Reply to a specific message (quoted reply)
whatsapp_send_template [#whatsapp_send_template]
Send a pre-approved template message
whatsapp_send_media [#whatsapp_send_media]
Send an image, video, document, or audio file by URL
whatsapp_send_reaction [#whatsapp_send_reaction]
React to a message with an emoji
whatsapp_send_location [#whatsapp_send_location]
Send a location pin
whatsapp_send_contact [#whatsapp_send_contact]
Send one or more vCard-style contact cards
whatsapp_send_interactive_buttons [#whatsapp_send_interactive_buttons]
Send a message with up to 3 quick-reply buttons
whatsapp_send_interactive_list [#whatsapp_send_interactive_list]
Send a message with a scrollable list of options
whatsapp_mark_read [#whatsapp_mark_read]
Mark a received message as read (shows blue ticks to sender)
whatsapp_get_media_url [#whatsapp_get_media_url]
Get the download URL and metadata for a received media object
whatsapp_delete_media [#whatsapp_delete_media]
Delete an uploaded media object from Meta's servers
whatsapp_list_templates [#whatsapp_list_templates]
List all message templates for a WhatsApp Business Account
whatsapp_get_template [#whatsapp_get_template]
Get a specific template by name
whatsapp_create_template [#whatsapp_create_template]
Create a new message template (submitted for Meta review)
whatsapp_delete_template [#whatsapp_delete_template]
Delete a template by name (all language variants)
whatsapp_get_phone_numbers [#whatsapp_get_phone_numbers]
List all phone numbers registered to a WABA
whatsapp_get_phone_number [#whatsapp_get_phone_number]
Get full details for a specific phone number
whatsapp_get_profile [#whatsapp_get_profile]
Get the public business profile for a phone number
whatsapp_update_profile [#whatsapp_update_profile]
Update the business profile (pass only the fields you want to change)
whatsapp_get_message_status [#whatsapp_get_message_status]
Get status of a sent message by message ID
whatsapp_create_qr_code [#whatsapp_create_qr_code]
Create a QR code that opens a chat with a prefilled message
whatsapp_update_qr_code [#whatsapp_update_qr_code]
Update qr code
whatsapp_list_qr_codes [#whatsapp_list_qr_codes]
List all QR codes for a phone number
whatsapp_get_qr_code [#whatsapp_get_qr_code]
Get qr code
whatsapp_delete_qr_code [#whatsapp_delete_qr_code]
Delete qr code
Notes [#notes]
* Category: Communication
* Authentication mode: OAuth
# WHOOP Integration
The WHOOP integration provides access to manage WHOOP get profile, get body measurement, list cycles, list recovery, list sleep through the Integrate MCP server.
Installation [#installation]
The WHOOP integration is included with the SDK:
```typescript
import { whoopIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a WHOOP OAuth App [#1-create-a-whoop-oauth-app]
1. Create an OAuth application for WHOOP
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the WHOOP integration to your server configuration. The integration automatically reads `WHOOP_CLIENT_ID` and `WHOOP_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, whoopIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
whoopIntegration({
scopes: ["read:profile", "read:cycles", "read:recovery", "read:sleep", "read:workout", "read:body_measurement"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
whoopIntegration({
clientId: process.env.CUSTOM_WHOOP_ID,
clientSecret: process.env.CUSTOM_WHOOP_SECRET,
scopes: ["read:profile", "read:cycles", "read:recovery", "read:sleep", "read:workout", "read:body_measurement"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("whoop");
const result = await client.whoop.getProfile({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, whoopIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [whoopIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `read:profile`
* `read:cycles`
* `read:recovery`
* `read:sleep`
* `read:workout`
* `read:body_measurement`
Tools [#tools]
whoop_get_profile [#whoop_get_profile]
Get profile
*No parameters.*
whoop_get_body_measurement [#whoop_get_body_measurement]
Get body measurement
*No parameters.*
whoop_list_cycles [#whoop_list_cycles]
List cycles
whoop_list_recovery [#whoop_list_recovery]
List recovery
whoop_list_sleep [#whoop_list_sleep]
List sleep
whoop_list_workouts [#whoop_list_workouts]
List workouts
Notes [#notes]
* Category: Fitness
* Authentication mode: OAuth
# Withings Integration
The Withings integration provides access to manage Withings get measurements, get activity, get sleep, get workouts, get user through the Integrate MCP server.
Installation [#installation]
The Withings integration is included with the SDK:
```typescript
import { withingsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Withings OAuth App [#1-create-a-withings-oauth-app]
1. Create an OAuth application for Withings
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Withings integration to your server configuration. The integration automatically reads `WITHINGS_CLIENT_ID` and `WITHINGS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, withingsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
withingsIntegration({
scopes: ["user.info", "user.metrics", "user.activity"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
withingsIntegration({
clientId: process.env.CUSTOM_WITHINGS_ID,
clientSecret: process.env.CUSTOM_WITHINGS_SECRET,
scopes: ["user.info", "user.metrics", "user.activity"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("withings");
const result = await client.withings.getMeasurements({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, withingsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [withingsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `user.info`
* `user.metrics`
* `user.activity`
Tools [#tools]
withings_get_measurements [#withings_get_measurements]
Get measurements
withings_get_activity [#withings_get_activity]
Get activity
withings_get_sleep [#withings_get_sleep]
Get sleep
withings_get_workouts [#withings_get_workouts]
Get workouts
withings_get_user [#withings_get_user]
Get user
Notes [#notes]
* Category: Fitness
* Authentication mode: OAuth
# Wix Integration
The Wix integration provides access to manage Wix site stores, products, and e-commerce orders via REST through the Integrate MCP server.
Installation [#installation]
The Wix integration is included with the SDK:
```typescript
import { wixIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add Wix to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, wixIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
wixIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.wix.queryProducts({});
console.log(result);
```
Environment Variables [#environment-variables]
* `WIX_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
wix_query_products [#wix_query_products]
Query products
wix_get_product [#wix_get_product]
Get product
wix_create_product [#wix_create_product]
Create product
wix_update_product [#wix_update_product]
Update product
wix_search_orders [#wix_search_orders]
Search orders
wix_get_order [#wix_get_order]
Get order
Notes [#notes]
* Category: Websites & CMS
* Authentication mode: API key
# Word Integration
The Word integration provides access to manage Word documents and sharing through the Integrate MCP server.
Installation [#installation]
The Word integration is included with the SDK:
```typescript
import { wordIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Word OAuth App [#1-create-a-word-oauth-app]
1. Go to [Azure Portal β App Registrations](https://portal.azure.com/#blade/Microsoft_AAD_RegisteredApps)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Word integration to your server configuration. The integration automatically reads `WORD_CLIENT_ID` and `WORD_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, wordIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
wordIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
wordIntegration({
clientId: process.env.CUSTOM_WORD_ID,
clientSecret: process.env.CUSTOM_WORD_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("word");
const result = await client.word.list({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, wordIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [wordIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
word_copy [#word_copy]
Copy a Word document
word_create [#word_create]
Create a new empty .docx file in OneDrive
word_delete [#word_delete]
Delete a Word document permanently
word_get [#word_get]
Get metadata for a Word document
word_list [#word_list]
Search for Word documents
word_share [#word_share]
Create a sharing link for a Word document
word_update_content [#word_update_content]
Update content
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# WordPress Integration
The WordPress integration provides access to manage WordPress get site, list posts, get post, create post, update post through the Integrate MCP server.
Installation [#installation]
The WordPress integration is included with the SDK:
```typescript
import { wordpressIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a WordPress OAuth App [#1-create-a-wordpress-oauth-app]
1. Create an OAuth application for WordPress
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the WordPress integration to your server configuration. The integration automatically reads `WORDPRESS_CLIENT_ID` and `WORDPRESS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, wordpressIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
wordpressIntegration({
scopes: ["global"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
wordpressIntegration({
clientId: process.env.CUSTOM_WORDPRESS_ID,
clientSecret: process.env.CUSTOM_WORDPRESS_SECRET,
scopes: ["global"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("wordpress");
const result = await client.wordpress.getSite({
site: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, wordpressIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [wordpressIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `global`
Tools [#tools]
wordpress_get_site [#wordpress_get_site]
Get site
wordpress_list_posts [#wordpress_list_posts]
List posts
wordpress_get_post [#wordpress_get_post]
Get post
wordpress_create_post [#wordpress_create_post]
Create post
wordpress_update_post [#wordpress_update_post]
Update post
wordpress_list_media [#wordpress_list_media]
List media
Notes [#notes]
* Category: Websites & CMS
* Authentication mode: OAuth
# Workday Integration
The Workday integration provides access to query Workday workers via the tenant REST API through the Integrate MCP server.
Installation [#installation]
The Workday integration is included with the SDK:
```typescript
import { workdayIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Workday OAuth App [#1-create-a-workday-oauth-app]
1. Create an OAuth application for Workday
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Workday integration to your server configuration. The integration automatically reads `WORKDAY_CLIENT_ID` and `WORKDAY_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, workdayIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
workdayIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
workdayIntegration({
clientId: process.env.CUSTOM_WORKDAY_ID,
clientSecret: process.env.CUSTOM_WORKDAY_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("workday");
const result = await client.workday.listWorkers({
hostname: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, workdayIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [workdayIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
workday_list_workers [#workday_list_workers]
List workers
workday_get_worker [#workday_get_worker]
Get worker
Notes [#notes]
* Category: HR & Recruiting
* Authentication mode: OAuth
# WorkOS Integration
The WorkOS integration provides access to manage WorkOS organizations, AuthKit users, memberships, and directory sync through the Integrate MCP server.
Installation [#installation]
The WorkOS integration is included with the SDK:
```typescript
import { workosIntegration } from "integrate-sdk/server";
```
Setup [#setup]
Add WorkOS to your server configuration. Provide credentials via environment variables or integration config:
```typescript
import { createMCPServer, workosIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
workosIntegration({
// See configuration options below
}),
],
});
```
Client-Side Usage [#client-side-usage]
```typescript
import { client } from "integrate-sdk";
const result = await client.workos.listOrganizations({});
console.log(result);
```
Environment Variables [#environment-variables]
* `WORKOS_API_KEY` (when supported by this integration)
Configuration Options [#configuration-options]
Tools [#tools]
workos_list_organizations [#workos_list_organizations]
List organizations
workos_get_organization [#workos_get_organization]
Get organization
workos_create_organization [#workos_create_organization]
Create organization
workos_update_organization [#workos_update_organization]
Update organization
workos_list_users [#workos_list_users]
List users
workos_get_user [#workos_get_user]
Get user
workos_list_organization_memberships [#workos_list_organization_memberships]
List organization memberships
workos_list_directories [#workos_list_directories]
List directories
workos_get_directory [#workos_get_directory]
Get directory
workos_list_directory_users [#workos_list_directory_users]
List directory users
workos_get_directory_user [#workos_get_directory_user]
Get directory user
Notes [#notes]
* Category: Identity & Access
* Authentication mode: API key
# X Integration
The X integration provides access to manage X users, posts, timelines, likes, bookmarks, follows, and posting through the Integrate MCP server.
Installation [#installation]
The X integration is included with the SDK:
```typescript
import { xIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a X OAuth App [#1-create-a-x-oauth-app]
1. Create an OAuth application for X
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the X integration to your server configuration. The integration automatically reads `X_CLIENT_ID` and `X_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, xIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
xIntegration({
scopes: ["tweet.read", "tweet.write", "users.read", "follows.read", "follows.write", "like.read", "like.write", "bookmark.read", "bookmark.write", "offline.access"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
xIntegration({
clientId: process.env.CUSTOM_X_ID,
clientSecret: process.env.CUSTOM_X_SECRET,
scopes: ["tweet.read", "tweet.write", "users.read", "follows.read", "follows.write", "like.read", "like.write", "bookmark.read", "bookmark.write", "offline.access"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("x");
const result = await client.x.getMe({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, xIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [xIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `tweet.read`
* `tweet.write`
* `users.read`
* `follows.read`
* `follows.write`
* `like.read`
* `like.write`
* `bookmark.read`
* `bookmark.write`
* `offline.access`
Tools [#tools]
x_get_me [#x_get_me]
Get me
x_get_user [#x_get_user]
Get user
x_search_posts [#x_search_posts]
Search posts
x_get_user_timeline [#x_get_user_timeline]
Get user timeline
x_create_post [#x_create_post]
Create post
x_delete_post [#x_delete_post]
Delete post
x_like_post [#x_like_post]
Like post
x_get_bookmarks [#x_get_bookmarks]
Get bookmarks
x_follow_user [#x_follow_user]
Follow user
Notes [#notes]
* Category: Social Media
* Authentication mode: OAuth
# Xero Integration
The Xero integration provides access to manage Xero organisations, accounts, contacts, invoices, and bank transactions through the Integrate MCP server.
Installation [#installation]
The Xero integration is included with the SDK:
```typescript
import { xeroIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Xero OAuth App [#1-create-a-xero-oauth-app]
1. Go to [Login Developer Portal](https://login.xero.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Xero integration to your server configuration. The integration automatically reads `XERO_CLIENT_ID` and `XERO_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, xeroIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
xeroIntegration({
scopes: ["openid", "profile", "email", "offline_access", "accounting.settings", "accounting.transactions", "accounting.contacts", "accounting.attachments"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
xeroIntegration({
clientId: process.env.CUSTOM_XERO_ID,
clientSecret: process.env.CUSTOM_XERO_SECRET,
scopes: ["openid", "profile", "email", "offline_access", "accounting.settings", "accounting.transactions", "accounting.contacts", "accounting.attachments"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("xero");
const result = await client.xero.listConnections({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, xeroIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [xeroIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `openid`
* `profile`
* `email`
* `offline_access`
* `accounting.settings`
* `accounting.transactions`
* `accounting.contacts`
* `accounting.attachments`
Tools [#tools]
xero_list_connections [#xero_list_connections]
List connections
*No parameters.*
xero_get_organisation [#xero_get_organisation]
Get organisation
xero_list_accounts [#xero_list_accounts]
List accounts
xero_list_contacts [#xero_list_contacts]
List contacts
xero_get_contact [#xero_get_contact]
Get contact
xero_create_contact [#xero_create_contact]
Create contact
xero_list_invoices [#xero_list_invoices]
List invoices
xero_get_invoice [#xero_get_invoice]
Get invoice
xero_create_invoice [#xero_create_invoice]
Create invoice
xero_list_bank_transactions [#xero_list_bank_transactions]
List bank transactions
Notes [#notes]
* Category: Accounting
* Authentication mode: OAuth
# YouTube Integration
The YouTube integration provides access to search and access YouTube videos and channels through the Integrate MCP server.
Installation [#installation]
The YouTube integration is included with the SDK:
```typescript
import { youtubeIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a YouTube OAuth App [#1-create-a-youtube-oauth-app]
1. Go to [Google Cloud Console](https://console.cloud.google.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the YouTube integration to your server configuration. The integration automatically reads `YOUTUBE_CLIENT_ID` and `YOUTUBE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, youtubeIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
youtubeIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
youtubeIntegration({
clientId: process.env.CUSTOM_YOUTUBE_ID,
clientSecret: process.env.CUSTOM_YOUTUBE_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("youtube");
const result = await client.youtube.search({
query: "value",
});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, youtubeIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [youtubeIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
youtube_add_comment [#youtube_add_comment]
Post a new top-level comment on a video
youtube_add_to_playlist [#youtube_add_to_playlist]
Add a video to a playlist
youtube_create_playlist [#youtube_create_playlist]
Create a new playlist
youtube_delete_playlist [#youtube_delete_playlist]
Permanently delete a playlist
youtube_get_captions [#youtube_get_captions]
List available caption tracks for a video
youtube_get_channel [#youtube_get_channel]
Get details for any channel by ID
youtube_get_my_channel [#youtube_get_my_channel]
Get the authenticated user's own channel
*No parameters.*
youtube_get_playlist [#youtube_get_playlist]
Get details for a specific playlist
youtube_get_video [#youtube_get_video]
Get full details for a specific video
youtube_get_video_rating [#youtube_get_video_rating]
Get the authenticated user's rating for one or more videos
youtube_list_comment_replies [#youtube_list_comment_replies]
List replies to a specific comment thread
youtube_list_comments [#youtube_list_comments]
List top-level comment threads on a video
youtube_list_my_videos [#youtube_list_my_videos]
List videos uploaded by the authenticated user
youtube_list_playlist_items [#youtube_list_playlist_items]
List videos in a playlist
youtube_list_playlists [#youtube_list_playlists]
List playlists for the authenticated user or a specific channel
youtube_list_subscriptions [#youtube_list_subscriptions]
List channels the authenticated user is subscribed to
youtube_rate_video [#youtube_rate_video]
Like, dislike, or remove a rating from a video
youtube_remove_from_playlist [#youtube_remove_from_playlist]
Remove an item from a playlist
youtube_reply_to_comment [#youtube_reply_to_comment]
Reply to an existing comment thread
youtube_search [#youtube_search]
Search for videos, channels, or playlists
youtube_subscribe [#youtube_subscribe]
Subscribe to a channel
youtube_unsubscribe [#youtube_unsubscribe]
Unsubscribe from a channel
youtube_update_playlist [#youtube_update_playlist]
Update a playlist's metadata
youtube_update_video [#youtube_update_video]
Update a video's metadata
Notes [#notes]
* Category: Entertainment
* Authentication mode: OAuth
# Zapier Integration
The Zapier integration provides access to list Zaps, browse apps, manage authentications, and inspect Zap runs via the Partner Workflow API through the Integrate MCP server.
Installation [#installation]
The Zapier integration is included with the SDK:
```typescript
import { zapierIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zapier OAuth App [#1-create-a-zapier-oauth-app]
1. Go to [Zapier Developer Portal](https://zapier.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zapier integration to your server configuration. The integration automatically reads `ZAPIER_CLIENT_ID` and `ZAPIER_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zapierIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zapierIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zapierIntegration({
clientId: process.env.CUSTOM_ZAPIER_ID,
clientSecret: process.env.CUSTOM_ZAPIER_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zapier");
const result = await client.zapier.getProfile({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zapierIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zapierIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
zapier_get_profile [#zapier_get_profile]
Get profile
*No parameters.*
zapier_list_zaps [#zapier_list_zaps]
List zaps
zapier_list_apps [#zapier_list_apps]
List apps
zapier_list_actions [#zapier_list_actions]
List actions
zapier_list_authentications [#zapier_list_authentications]
List authentications
zapier_list_zap_runs [#zapier_list_zap_runs]
List zap runs
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Zendesk Integration
The Zendesk integration provides access to manage Zendesk tickets, users, and help center content through the Integrate MCP server.
Installation [#installation]
The Zendesk integration is included with the SDK:
```typescript
import { zendeskIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zendesk OAuth App [#1-create-a-zendesk-oauth-app]
1. Create an OAuth application for Zendesk
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zendesk integration to your server configuration. The integration automatically reads `ZENDESK_CLIENT_ID` and `ZENDESK_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zendeskIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zendeskIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zendeskIntegration({
clientId: process.env.CUSTOM_ZENDESK_ID,
clientSecret: process.env.CUSTOM_ZENDESK_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zendesk");
const result = await client.zendesk.listTickets({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zendeskIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zendeskIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
zendesk_list_tickets [#zendesk_list_tickets]
List tickets
zendesk_get_ticket [#zendesk_get_ticket]
Get a specific ticket
zendesk_create_ticket [#zendesk_create_ticket]
Create a new ticket
zendesk_update_ticket [#zendesk_update_ticket]
Update an existing ticket
zendesk_delete_ticket [#zendesk_delete_ticket]
Delete a ticket
zendesk_add_comment [#zendesk_add_comment]
Add a comment to a ticket
zendesk_list_ticket_comments [#zendesk_list_ticket_comments]
List comments on a ticket
zendesk_list_users [#zendesk_list_users]
List users
zendesk_get_user [#zendesk_get_user]
Get a specific user
zendesk_create_user [#zendesk_create_user]
Create a new user
zendesk_update_user [#zendesk_update_user]
Update an existing user
zendesk_search_users [#zendesk_search_users]
Search for users
zendesk_list_organizations [#zendesk_list_organizations]
List organizations
zendesk_get_organization [#zendesk_get_organization]
Get a specific organization
zendesk_create_organization [#zendesk_create_organization]
Create a new organization
zendesk_update_organization [#zendesk_update_organization]
Update an existing organization
zendesk_list_groups [#zendesk_list_groups]
List groups
zendesk_get_group [#zendesk_get_group]
Get a specific group
zendesk_search_tickets [#zendesk_search_tickets]
Search for tickets
zendesk_search [#zendesk_search]
Search across all Zendesk resources (tickets, users, organizations)
zendesk_list_views [#zendesk_list_views]
List views
zendesk_get_view_tickets [#zendesk_get_view_tickets]
Get tickets from a specific view
zendesk_list_macros [#zendesk_list_macros]
List macros
zendesk_list_tags [#zendesk_list_tags]
List tags
*No parameters.*
zendesk_add_tags [#zendesk_add_tags]
Add tags to a ticket
zendesk_remove_tags [#zendesk_remove_tags]
Remove tags from a ticket
Notes [#notes]
* Category: Business
* Authentication mode: OAuth
# Zoho Analytics Integration
The Zoho Analytics integration provides access to manage Zoho Analytics workspaces, views, imports, exports, and query APIs through the Integrate MCP server.
Installation [#installation]
The Zoho Analytics integration is included with the SDK:
```typescript
import { zohoAnalyticsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoho Analytics OAuth App [#1-create-a-zoho-analytics-oauth-app]
1. Go to [Zoho API Console](https://api-console.zoho.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoho Analytics integration to your server configuration. The integration automatically reads `ZOHO_ANALYTICS_CLIENT_ID` and `ZOHO_ANALYTICS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zohoAnalyticsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zohoAnalyticsIntegration({
scopes: ["ZohoAnalytics.fullaccess.all"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zohoAnalyticsIntegration({
clientId: process.env.CUSTOM_ZOHO_ANALYTICS_ID,
clientSecret: process.env.CUSTOM_ZOHO_ANALYTICS_SECRET,
scopes: ["ZohoAnalytics.fullaccess.all"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoho_analytics");
const result = await client.zoho_analytics.listWorkspaces({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zohoAnalyticsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zohoAnalyticsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `ZohoAnalytics.fullaccess.all`
Tools [#tools]
zoho_analytics_list_workspaces [#zoho_analytics_list_workspaces]
Analytics list workspaces
*No parameters.*
zoho_analytics_get_workspace [#zoho_analytics_get_workspace]
Analytics get workspace
zoho_analytics_list_views [#zoho_analytics_list_views]
Analytics list views
zoho_analytics_export_view [#zoho_analytics_export_view]
Analytics export view
zoho_analytics_import_data [#zoho_analytics_import_data]
Analytics import data
zoho_analytics_query [#zoho_analytics_query]
Analytics query
Notes [#notes]
* Category: Analytics
* Authentication mode: OAuth
# Zoho Billing Integration
The Zoho Billing integration provides access to manage Zoho Billing organizations, customers, items, subscriptions, and invoices through the Integrate MCP server.
Installation [#installation]
The Zoho Billing integration is included with the SDK:
```typescript
import { zohoBillingIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoho Billing OAuth App [#1-create-a-zoho-billing-oauth-app]
1. Go to [Zoho API Console](https://api-console.zoho.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoho Billing integration to your server configuration. The integration automatically reads `ZOHO_BILLING_CLIENT_ID` and `ZOHO_BILLING_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zohoBillingIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zohoBillingIntegration({
scopes: ["ZohoBilling.fullaccess.all"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zohoBillingIntegration({
clientId: process.env.CUSTOM_ZOHO_BILLING_ID,
clientSecret: process.env.CUSTOM_ZOHO_BILLING_SECRET,
scopes: ["ZohoBilling.fullaccess.all"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoho_billing");
const result = await client.zoho_billing.listOrganizations({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zohoBillingIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zohoBillingIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `ZohoBilling.fullaccess.all`
Tools [#tools]
zoho_billing_list_organizations [#zoho_billing_list_organizations]
Billing list organizations
*No parameters.*
zoho_billing_list_customers [#zoho_billing_list_customers]
Billing list customers
zoho_billing_list_items [#zoho_billing_list_items]
Billing list items
zoho_billing_list_subscriptions [#zoho_billing_list_subscriptions]
Billing list subscriptions
zoho_billing_create_subscription [#zoho_billing_create_subscription]
Billing create subscription
zoho_billing_list_invoices [#zoho_billing_list_invoices]
Billing list invoices
Notes [#notes]
* Category: Accounting
* Authentication mode: OAuth
# Zoho Books Integration
The Zoho Books integration provides access to manage Zoho Books organizations, contacts, items, invoices, bills, payments, and reports through the Integrate MCP server.
Installation [#installation]
The Zoho Books integration is included with the SDK:
```typescript
import { zohoBooksIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoho Books OAuth App [#1-create-a-zoho-books-oauth-app]
1. Go to [Zoho API Console](https://api-console.zoho.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoho Books integration to your server configuration. The integration automatically reads `ZOHO_BOOKS_CLIENT_ID` and `ZOHO_BOOKS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zohoBooksIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zohoBooksIntegration({
scopes: ["ZohoBooks.fullaccess.all"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zohoBooksIntegration({
clientId: process.env.CUSTOM_ZOHO_BOOKS_ID,
clientSecret: process.env.CUSTOM_ZOHO_BOOKS_SECRET,
scopes: ["ZohoBooks.fullaccess.all"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoho_books");
const result = await client.zoho_books.listOrganizations({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zohoBooksIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zohoBooksIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `ZohoBooks.fullaccess.all`
Tools [#tools]
zoho_books_list_organizations [#zoho_books_list_organizations]
Books list organizations
zoho_books_list_contacts [#zoho_books_list_contacts]
Books list contacts
zoho_books_list_items [#zoho_books_list_items]
Books list items
zoho_books_list_invoices [#zoho_books_list_invoices]
Books list invoices
zoho_books_list_bills [#zoho_books_list_bills]
Books list bills
zoho_books_list_customerpayments [#zoho_books_list_customerpayments]
Books list customerpayments
zoho_books_create_invoice [#zoho_books_create_invoice]
Books create invoice
zoho_books_profit_and_loss [#zoho_books_profit_and_loss]
Books profit and loss
Notes [#notes]
* Category: Accounting
* Authentication mode: OAuth
# Zoho Campaigns Integration
The Zoho Campaigns integration provides access to manage Zoho Campaigns lists, contacts, campaigns, reports, and sends through the Integrate MCP server.
Installation [#installation]
The Zoho Campaigns integration is included with the SDK:
```typescript
import { zohoCampaignsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoho Campaigns OAuth App [#1-create-a-zoho-campaigns-oauth-app]
1. Go to [Zoho API Console](https://api-console.zoho.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoho Campaigns integration to your server configuration. The integration automatically reads `ZOHO_CAMPAIGNS_CLIENT_ID` and `ZOHO_CAMPAIGNS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zohoCampaignsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zohoCampaignsIntegration({
scopes: ["ZohoCampaigns.campaign.ALL", "ZohoCampaigns.contact.ALL", "ZohoCampaigns.report.READ"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zohoCampaignsIntegration({
clientId: process.env.CUSTOM_ZOHO_CAMPAIGNS_ID,
clientSecret: process.env.CUSTOM_ZOHO_CAMPAIGNS_SECRET,
scopes: ["ZohoCampaigns.campaign.ALL", "ZohoCampaigns.contact.ALL", "ZohoCampaigns.report.READ"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoho_campaigns");
const result = await client.zoho_campaigns.listMailingLists({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zohoCampaignsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zohoCampaignsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `ZohoCampaigns.campaign.ALL`
* `ZohoCampaigns.contact.ALL`
* `ZohoCampaigns.report.READ`
Tools [#tools]
zoho_campaigns_list_mailing_lists [#zoho_campaigns_list_mailing_lists]
Campaigns list mailing lists
*No parameters.*
zoho_campaigns_list_contacts [#zoho_campaigns_list_contacts]
Campaigns list contacts
zoho_campaigns_add_contact [#zoho_campaigns_add_contact]
Campaigns add contact
zoho_campaigns_list_campaigns [#zoho_campaigns_list_campaigns]
Campaigns list campaigns
zoho_campaigns_get_campaign_report [#zoho_campaigns_get_campaign_report]
Campaigns get campaign report
zoho_campaigns_send_campaign [#zoho_campaigns_send_campaign]
Campaigns send campaign
Notes [#notes]
* Category: Marketing
* Authentication mode: OAuth
# Zoho Creator Integration
The Zoho Creator integration provides access to manage Zoho Creator applications, forms, reports, and app records through the Integrate MCP server.
Installation [#installation]
The Zoho Creator integration is included with the SDK:
```typescript
import { zohoCreatorIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoho Creator OAuth App [#1-create-a-zoho-creator-oauth-app]
1. Go to [Zoho API Console](https://api-console.zoho.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoho Creator integration to your server configuration. The integration automatically reads `ZOHO_CREATOR_CLIENT_ID` and `ZOHO_CREATOR_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zohoCreatorIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zohoCreatorIntegration({
scopes: ["ZohoCreator.meta.READ", "ZohoCreator.data.READ", "ZohoCreator.data.CREATE", "ZohoCreator.data.UPDATE"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zohoCreatorIntegration({
clientId: process.env.CUSTOM_ZOHO_CREATOR_ID,
clientSecret: process.env.CUSTOM_ZOHO_CREATOR_SECRET,
scopes: ["ZohoCreator.meta.READ", "ZohoCreator.data.READ", "ZohoCreator.data.CREATE", "ZohoCreator.data.UPDATE"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoho_creator");
const result = await client.zoho_creator.listApplications({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zohoCreatorIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zohoCreatorIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `ZohoCreator.meta.READ`
* `ZohoCreator.data.READ`
* `ZohoCreator.data.CREATE`
* `ZohoCreator.data.UPDATE`
Tools [#tools]
zoho_creator_list_applications [#zoho_creator_list_applications]
Creator list applications
zoho_creator_list_forms [#zoho_creator_list_forms]
Creator list forms
zoho_creator_list_reports [#zoho_creator_list_reports]
Creator list reports
zoho_creator_list_records [#zoho_creator_list_records]
Creator list records
zoho_creator_create_record [#zoho_creator_create_record]
Creator create record
zoho_creator_update_record [#zoho_creator_update_record]
Creator update record
Notes [#notes]
* Category: Business
* Authentication mode: OAuth
# Zoho CRM Integration
The Zoho CRM integration provides access to manage Zoho CRM modules, records, users, org settings, search, and COQL through the Integrate MCP server.
Installation [#installation]
The Zoho CRM integration is included with the SDK:
```typescript
import { zohoCrmIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoho CRM OAuth App [#1-create-a-zoho-crm-oauth-app]
1. Go to [Zoho API Console](https://api-console.zoho.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoho CRM integration to your server configuration. The integration automatically reads `ZOHO_CRM_CLIENT_ID` and `ZOHO_CRM_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zohoCrmIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zohoCrmIntegration({
scopes: ["ZohoCRM.modules.ALL", "ZohoCRM.settings.ALL", "ZohoCRM.users.ALL"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zohoCrmIntegration({
clientId: process.env.CUSTOM_ZOHO_CRM_ID,
clientSecret: process.env.CUSTOM_ZOHO_CRM_SECRET,
scopes: ["ZohoCRM.modules.ALL", "ZohoCRM.settings.ALL", "ZohoCRM.users.ALL"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoho_crm");
const result = await client.zoho_crm.listModules({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zohoCrmIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zohoCrmIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `ZohoCRM.modules.ALL`
* `ZohoCRM.settings.ALL`
* `ZohoCRM.users.ALL`
Tools [#tools]
zoho_crm_list_modules [#zoho_crm_list_modules]
Crm list modules
*No parameters.*
zoho_crm_list_records [#zoho_crm_list_records]
Crm list records
zoho_crm_get_record [#zoho_crm_get_record]
Crm get record
zoho_crm_create_records [#zoho_crm_create_records]
Crm create records
zoho_crm_update_record [#zoho_crm_update_record]
Crm update record
zoho_crm_search_records [#zoho_crm_search_records]
Crm search records
zoho_crm_coql_query [#zoho_crm_coql_query]
Crm coql query
zoho_crm_list_users [#zoho_crm_list_users]
Crm list users
zoho_crm_get_org [#zoho_crm_get_org]
Crm get org
*No parameters.*
Notes [#notes]
* Category: Business
* Authentication mode: OAuth
# Zoho Desk Integration
The Zoho Desk integration provides access to manage Zoho Desk tickets, contacts, accounts, agents, departments, and articles through the Integrate MCP server.
Installation [#installation]
The Zoho Desk integration is included with the SDK:
```typescript
import { zohoDeskIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoho Desk OAuth App [#1-create-a-zoho-desk-oauth-app]
1. Go to [Zoho API Console](https://api-console.zoho.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoho Desk integration to your server configuration. The integration automatically reads `ZOHO_DESK_CLIENT_ID` and `ZOHO_DESK_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zohoDeskIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zohoDeskIntegration({
scopes: ["Desk.tickets.ALL", "Desk.contacts.ALL", "Desk.settings.READ"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zohoDeskIntegration({
clientId: process.env.CUSTOM_ZOHO_DESK_ID,
clientSecret: process.env.CUSTOM_ZOHO_DESK_SECRET,
scopes: ["Desk.tickets.ALL", "Desk.contacts.ALL", "Desk.settings.READ"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoho_desk");
const result = await client.zoho_desk.listTickets({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zohoDeskIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zohoDeskIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `Desk.tickets.ALL`
* `Desk.contacts.ALL`
* `Desk.settings.READ`
Tools [#tools]
zoho_desk_list_tickets [#zoho_desk_list_tickets]
Desk list tickets
zoho_desk_get_ticket [#zoho_desk_get_ticket]
Desk get ticket
zoho_desk_create_ticket [#zoho_desk_create_ticket]
Desk create ticket
zoho_desk_list_contacts [#zoho_desk_list_contacts]
Desk list contacts
zoho_desk_list_accounts [#zoho_desk_list_accounts]
Desk list accounts
zoho_desk_list_agents [#zoho_desk_list_agents]
Desk list agents
*No parameters.*
zoho_desk_list_departments [#zoho_desk_list_departments]
Desk list departments
*No parameters.*
zoho_desk_search_articles [#zoho_desk_search_articles]
Desk search articles
Notes [#notes]
* Category: Business
* Authentication mode: OAuth
# Zoho Inventory Integration
The Zoho Inventory integration provides access to manage Zoho Inventory organizations, contacts, items, sales orders, packages, and shipments through the Integrate MCP server.
Installation [#installation]
The Zoho Inventory integration is included with the SDK:
```typescript
import { zohoInventoryIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoho Inventory OAuth App [#1-create-a-zoho-inventory-oauth-app]
1. Go to [Zoho API Console](https://api-console.zoho.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoho Inventory integration to your server configuration. The integration automatically reads `ZOHO_INVENTORY_CLIENT_ID` and `ZOHO_INVENTORY_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zohoInventoryIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zohoInventoryIntegration({
scopes: ["ZohoInventory.fullaccess.all"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zohoInventoryIntegration({
clientId: process.env.CUSTOM_ZOHO_INVENTORY_ID,
clientSecret: process.env.CUSTOM_ZOHO_INVENTORY_SECRET,
scopes: ["ZohoInventory.fullaccess.all"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoho_inventory");
const result = await client.zoho_inventory.listOrganizations({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zohoInventoryIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zohoInventoryIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `ZohoInventory.fullaccess.all`
Tools [#tools]
zoho_inventory_list_organizations [#zoho_inventory_list_organizations]
Inventory list organizations
*No parameters.*
zoho_inventory_list_contacts [#zoho_inventory_list_contacts]
Inventory list contacts
zoho_inventory_list_items [#zoho_inventory_list_items]
Inventory list items
zoho_inventory_list_sales_orders [#zoho_inventory_list_sales_orders]
Inventory list sales orders
zoho_inventory_create_sales_order [#zoho_inventory_create_sales_order]
Inventory create sales order
zoho_inventory_list_packages [#zoho_inventory_list_packages]
Inventory list packages
Notes [#notes]
* Category: Commerce
* Authentication mode: OAuth
# Zoho Invoice Integration
The Zoho Invoice integration provides access to manage Zoho Invoice organizations, customers, items, estimates, invoices, payments, and reports through the Integrate MCP server.
Installation [#installation]
The Zoho Invoice integration is included with the SDK:
```typescript
import { zohoInvoiceIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoho Invoice OAuth App [#1-create-a-zoho-invoice-oauth-app]
1. Go to [Zoho API Console](https://api-console.zoho.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoho Invoice integration to your server configuration. The integration automatically reads `ZOHO_INVOICE_CLIENT_ID` and `ZOHO_INVOICE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zohoInvoiceIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zohoInvoiceIntegration({
scopes: ["ZohoInvoice.fullaccess.all"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zohoInvoiceIntegration({
clientId: process.env.CUSTOM_ZOHO_INVOICE_ID,
clientSecret: process.env.CUSTOM_ZOHO_INVOICE_SECRET,
scopes: ["ZohoInvoice.fullaccess.all"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoho_invoice");
const result = await client.zoho_invoice.listOrganizations({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zohoInvoiceIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zohoInvoiceIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `ZohoInvoice.fullaccess.all`
Tools [#tools]
zoho_invoice_list_organizations [#zoho_invoice_list_organizations]
Invoice list organizations
zoho_invoice_list_contacts [#zoho_invoice_list_contacts]
Invoice list contacts
zoho_invoice_list_items [#zoho_invoice_list_items]
Invoice list items
zoho_invoice_list_estimates [#zoho_invoice_list_estimates]
Invoice list estimates
zoho_invoice_list_invoices [#zoho_invoice_list_invoices]
Invoice list invoices
zoho_invoice_list_customerpayments [#zoho_invoice_list_customerpayments]
Invoice list customerpayments
zoho_invoice_create_invoice [#zoho_invoice_create_invoice]
Invoice create invoice
zoho_invoice_get_aging_summary [#zoho_invoice_get_aging_summary]
Invoice get aging summary
Notes [#notes]
* Category: Accounting
* Authentication mode: OAuth
# Zoho Mail Integration
The Zoho Mail integration provides access to manage Zoho Mail accounts, folders, messages, labels, search, and sending through the Integrate MCP server.
Installation [#installation]
The Zoho Mail integration is included with the SDK:
```typescript
import { zohoMailIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoho Mail OAuth App [#1-create-a-zoho-mail-oauth-app]
1. Go to [Zoho API Console](https://api-console.zoho.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoho Mail integration to your server configuration. The integration automatically reads `ZOHO_MAIL_CLIENT_ID` and `ZOHO_MAIL_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zohoMailIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zohoMailIntegration({
scopes: ["ZohoMail.accounts.READ", "ZohoMail.messages.ALL", "ZohoMail.folders.ALL"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zohoMailIntegration({
clientId: process.env.CUSTOM_ZOHO_MAIL_ID,
clientSecret: process.env.CUSTOM_ZOHO_MAIL_SECRET,
scopes: ["ZohoMail.accounts.READ", "ZohoMail.messages.ALL", "ZohoMail.folders.ALL"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoho_mail");
const result = await client.zoho_mail.listAccounts({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zohoMailIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zohoMailIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `ZohoMail.accounts.READ`
* `ZohoMail.messages.ALL`
* `ZohoMail.folders.ALL`
Tools [#tools]
zoho_mail_list_accounts [#zoho_mail_list_accounts]
Mail list accounts
*No parameters.*
zoho_mail_list_folders [#zoho_mail_list_folders]
Mail list folders
zoho_mail_list_messages [#zoho_mail_list_messages]
Mail list messages
zoho_mail_get_message [#zoho_mail_get_message]
Mail get message
zoho_mail_send_message [#zoho_mail_send_message]
Mail send message
zoho_mail_search_messages [#zoho_mail_search_messages]
Mail search messages
zoho_mail_list_labels [#zoho_mail_list_labels]
Mail list labels
Notes [#notes]
* Category: Communication
* Authentication mode: OAuth
# Zoho People Integration
The Zoho People integration provides access to manage Zoho People forms, employees, attendance, leave requests, and time tracking through the Integrate MCP server.
Installation [#installation]
The Zoho People integration is included with the SDK:
```typescript
import { zohoPeopleIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoho People OAuth App [#1-create-a-zoho-people-oauth-app]
1. Go to [Zoho API Console](https://api-console.zoho.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoho People integration to your server configuration. The integration automatically reads `ZOHO_PEOPLE_CLIENT_ID` and `ZOHO_PEOPLE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zohoPeopleIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zohoPeopleIntegration({
scopes: ["ZohoPeople.forms.ALL", "ZohoPeople.employee.ALL", "ZohoPeople.leave.ALL", "ZohoPeople.attendance.ALL"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zohoPeopleIntegration({
clientId: process.env.CUSTOM_ZOHO_PEOPLE_ID,
clientSecret: process.env.CUSTOM_ZOHO_PEOPLE_SECRET,
scopes: ["ZohoPeople.forms.ALL", "ZohoPeople.employee.ALL", "ZohoPeople.leave.ALL", "ZohoPeople.attendance.ALL"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoho_people");
const result = await client.zoho_people.listForms({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zohoPeopleIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zohoPeopleIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `ZohoPeople.forms.ALL`
* `ZohoPeople.employee.ALL`
* `ZohoPeople.leave.ALL`
* `ZohoPeople.attendance.ALL`
Tools [#tools]
zoho_people_list_forms [#zoho_people_list_forms]
People list forms
*No parameters.*
zoho_people_list_employees [#zoho_people_list_employees]
People list employees
zoho_people_get_employee [#zoho_people_get_employee]
People get employee
zoho_people_list_attendance [#zoho_people_list_attendance]
People list attendance
zoho_people_list_leave_requests [#zoho_people_list_leave_requests]
People list leave requests
zoho_people_list_time_logs [#zoho_people_list_time_logs]
People list time logs
Notes [#notes]
* Category: HR & Recruiting
* Authentication mode: OAuth
# Zoho Projects Integration
The Zoho Projects integration provides access to manage Zoho Projects portals, projects, milestones, tasks, issues, and timesheets through the Integrate MCP server.
Installation [#installation]
The Zoho Projects integration is included with the SDK:
```typescript
import { zohoProjectsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoho Projects OAuth App [#1-create-a-zoho-projects-oauth-app]
1. Go to [Zoho API Console](https://api-console.zoho.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoho Projects integration to your server configuration. The integration automatically reads `ZOHO_PROJECTS_CLIENT_ID` and `ZOHO_PROJECTS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zohoProjectsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zohoProjectsIntegration({
scopes: ["ZohoProjects.portals.ALL", "ZohoProjects.projects.ALL", "ZohoProjects.tasks.ALL", "ZohoProjects.issues.ALL"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zohoProjectsIntegration({
clientId: process.env.CUSTOM_ZOHO_PROJECTS_ID,
clientSecret: process.env.CUSTOM_ZOHO_PROJECTS_SECRET,
scopes: ["ZohoProjects.portals.ALL", "ZohoProjects.projects.ALL", "ZohoProjects.tasks.ALL", "ZohoProjects.issues.ALL"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoho_projects");
const result = await client.zoho_projects.listPortals({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zohoProjectsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zohoProjectsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `ZohoProjects.portals.ALL`
* `ZohoProjects.projects.ALL`
* `ZohoProjects.tasks.ALL`
* `ZohoProjects.issues.ALL`
Tools [#tools]
zoho_projects_list_portals [#zoho_projects_list_portals]
Projects list portals
*No parameters.*
zoho_projects_list_projects [#zoho_projects_list_projects]
Projects list projects
zoho_projects_get_project [#zoho_projects_get_project]
Projects get project
zoho_projects_list_milestones [#zoho_projects_list_milestones]
Projects list milestones
zoho_projects_list_tasklists [#zoho_projects_list_tasklists]
Projects list tasklists
zoho_projects_list_tasks [#zoho_projects_list_tasks]
Projects list tasks
zoho_projects_create_task [#zoho_projects_create_task]
Projects create task
zoho_projects_list_issues [#zoho_projects_list_issues]
Projects list issues
zoho_projects_list_timesheets [#zoho_projects_list_timesheets]
Projects list timesheets
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Zoho Recruit Integration
The Zoho Recruit integration provides access to manage Zoho Recruit candidates, job openings, interviews, and custom modules through the Integrate MCP server.
Installation [#installation]
The Zoho Recruit integration is included with the SDK:
```typescript
import { zohoRecruitIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoho Recruit OAuth App [#1-create-a-zoho-recruit-oauth-app]
1. Go to [Zoho API Console](https://api-console.zoho.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoho Recruit integration to your server configuration. The integration automatically reads `ZOHO_RECRUIT_CLIENT_ID` and `ZOHO_RECRUIT_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zohoRecruitIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zohoRecruitIntegration({
scopes: ["ZohoRecruit.modules.ALL", "ZohoRecruit.settings.ALL"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zohoRecruitIntegration({
clientId: process.env.CUSTOM_ZOHO_RECRUIT_ID,
clientSecret: process.env.CUSTOM_ZOHO_RECRUIT_SECRET,
scopes: ["ZohoRecruit.modules.ALL", "ZohoRecruit.settings.ALL"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoho_recruit");
const result = await client.zoho_recruit.listModules({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zohoRecruitIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zohoRecruitIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `ZohoRecruit.modules.ALL`
* `ZohoRecruit.settings.ALL`
Tools [#tools]
zoho_recruit_list_modules [#zoho_recruit_list_modules]
Recruit list modules
*No parameters.*
zoho_recruit_list_candidates [#zoho_recruit_list_candidates]
Recruit list candidates
zoho_recruit_get_candidate [#zoho_recruit_get_candidate]
Recruit get candidate
zoho_recruit_create_candidate [#zoho_recruit_create_candidate]
Recruit create candidate
zoho_recruit_list_job_openings [#zoho_recruit_list_job_openings]
Recruit list job openings
zoho_recruit_list_interviews [#zoho_recruit_list_interviews]
Recruit list interviews
Notes [#notes]
* Category: HR & Recruiting
* Authentication mode: OAuth
# Zoho Sign Integration
The Zoho Sign integration provides access to manage Zoho Sign requests, templates, contacts, and signature workflows through the Integrate MCP server.
Installation [#installation]
The Zoho Sign integration is included with the SDK:
```typescript
import { zohoSignIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoho Sign OAuth App [#1-create-a-zoho-sign-oauth-app]
1. Go to [Zoho API Console](https://api-console.zoho.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoho Sign integration to your server configuration. The integration automatically reads `ZOHO_SIGN_CLIENT_ID` and `ZOHO_SIGN_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zohoSignIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zohoSignIntegration({
scopes: ["ZohoSign.documents.ALL", "ZohoSign.templates.READ", "ZohoSign.account.READ"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zohoSignIntegration({
clientId: process.env.CUSTOM_ZOHO_SIGN_ID,
clientSecret: process.env.CUSTOM_ZOHO_SIGN_SECRET,
scopes: ["ZohoSign.documents.ALL", "ZohoSign.templates.READ", "ZohoSign.account.READ"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoho_sign");
const result = await client.zoho_sign.listRequests({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zohoSignIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zohoSignIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `ZohoSign.documents.ALL`
* `ZohoSign.templates.READ`
* `ZohoSign.account.READ`
Tools [#tools]
zoho_sign_list_requests [#zoho_sign_list_requests]
Sign list requests
zoho_sign_get_request [#zoho_sign_get_request]
Sign get request
zoho_sign_create_request [#zoho_sign_create_request]
Sign create request
zoho_sign_list_templates [#zoho_sign_list_templates]
Sign list templates
zoho_sign_get_template [#zoho_sign_get_template]
Sign get template
zoho_sign_list_contacts [#zoho_sign_list_contacts]
Sign list contacts
Notes [#notes]
* Category: Legal
* Authentication mode: OAuth
# Zoho Sprints Integration
The Zoho Sprints integration provides access to manage Zoho Sprints portals, projects, sprints, epics, and work items through the Integrate MCP server.
Installation [#installation]
The Zoho Sprints integration is included with the SDK:
```typescript
import { zohoSprintsIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoho Sprints OAuth App [#1-create-a-zoho-sprints-oauth-app]
1. Go to [Zoho API Console](https://api-console.zoho.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoho Sprints integration to your server configuration. The integration automatically reads `ZOHO_SPRINTS_CLIENT_ID` and `ZOHO_SPRINTS_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zohoSprintsIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zohoSprintsIntegration({
scopes: ["ZohoSprints.projects.ALL", "ZohoSprints.sprints.ALL", "ZohoSprints.workitems.ALL", "ZohoSprints.epics.ALL"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zohoSprintsIntegration({
clientId: process.env.CUSTOM_ZOHO_SPRINTS_ID,
clientSecret: process.env.CUSTOM_ZOHO_SPRINTS_SECRET,
scopes: ["ZohoSprints.projects.ALL", "ZohoSprints.sprints.ALL", "ZohoSprints.workitems.ALL", "ZohoSprints.epics.ALL"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoho_sprints");
const result = await client.zoho_sprints.listPortals({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zohoSprintsIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zohoSprintsIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `ZohoSprints.projects.ALL`
* `ZohoSprints.sprints.ALL`
* `ZohoSprints.workitems.ALL`
* `ZohoSprints.epics.ALL`
Tools [#tools]
zoho_sprints_list_portals [#zoho_sprints_list_portals]
Sprints list portals
*No parameters.*
zoho_sprints_list_projects [#zoho_sprints_list_projects]
Sprints list projects
zoho_sprints_list_sprints [#zoho_sprints_list_sprints]
Sprints list sprints
zoho_sprints_list_work_items [#zoho_sprints_list_work_items]
Sprints list work items
zoho_sprints_create_work_item [#zoho_sprints_create_work_item]
Sprints create work item
zoho_sprints_list_epics [#zoho_sprints_list_epics]
Sprints list epics
Notes [#notes]
* Category: Engineering
* Authentication mode: OAuth
# Zoho WorkDrive Integration
The Zoho WorkDrive integration provides access to manage Zoho WorkDrive team folders, files, folders, and collaborators through the Integrate MCP server.
Installation [#installation]
The Zoho WorkDrive integration is included with the SDK:
```typescript
import { zohoWorkdriveIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoho WorkDrive OAuth App [#1-create-a-zoho-workdrive-oauth-app]
1. Go to [Zoho API Console](https://api-console.zoho.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoho WorkDrive integration to your server configuration. The integration automatically reads `ZOHO_WORKDRIVE_CLIENT_ID` and `ZOHO_WORKDRIVE_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zohoWorkdriveIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zohoWorkdriveIntegration({
scopes: ["WorkDrive.files.ALL", "WorkDrive.teamfolders.READ", "WorkDrive.users.READ"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zohoWorkdriveIntegration({
clientId: process.env.CUSTOM_ZOHO_WORKDRIVE_ID,
clientSecret: process.env.CUSTOM_ZOHO_WORKDRIVE_SECRET,
scopes: ["WorkDrive.files.ALL", "WorkDrive.teamfolders.READ", "WorkDrive.users.READ"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoho_workdrive");
const result = await client.zoho_workdrive.listTeams({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zohoWorkdriveIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zohoWorkdriveIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `WorkDrive.files.ALL`
* `WorkDrive.teamfolders.READ`
* `WorkDrive.users.READ`
Tools [#tools]
zoho_workdrive_list_teams [#zoho_workdrive_list_teams]
Workdrive list teams
*No parameters.*
zoho_workdrive_list_team_folders [#zoho_workdrive_list_team_folders]
Workdrive list team folders
zoho_workdrive_get_team_folder [#zoho_workdrive_get_team_folder]
Workdrive get team folder
zoho_workdrive_list_files [#zoho_workdrive_list_files]
Workdrive list files
zoho_workdrive_get_file [#zoho_workdrive_get_file]
Workdrive get file
zoho_workdrive_create_folder [#zoho_workdrive_create_folder]
Workdrive create folder
Notes [#notes]
* Category: Storage
* Authentication mode: OAuth
# Zoho Writer Integration
The Zoho Writer integration provides access to manage Zoho Writer documents, templates, merges, and exports through the Integrate MCP server.
Installation [#installation]
The Zoho Writer integration is included with the SDK:
```typescript
import { zohoWriterIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoho Writer OAuth App [#1-create-a-zoho-writer-oauth-app]
1. Go to [Zoho API Console](https://api-console.zoho.com)
2. Create a new OAuth application
3. Configure your redirect URI
4. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoho Writer integration to your server configuration. The integration automatically reads `ZOHO_WRITER_CLIENT_ID` and `ZOHO_WRITER_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zohoWriterIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zohoWriterIntegration({
scopes: ["ZohoWriter.documentEditor.ALL", "ZohoWriter.merge.ALL"], // Optional
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zohoWriterIntegration({
clientId: process.env.CUSTOM_ZOHO_WRITER_ID,
clientSecret: process.env.CUSTOM_ZOHO_WRITER_SECRET,
scopes: ["ZohoWriter.documentEditor.ALL", "ZohoWriter.merge.ALL"], // Optional
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoho_writer");
const result = await client.zoho_writer.listDocuments({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zohoWriterIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zohoWriterIntegration()],
});
```
Configuration Options [#configuration-options]
Default Scopes [#default-scopes]
These defaults are applied unless you override `scopes` in the integration config:
* `ZohoWriter.documentEditor.ALL`
* `ZohoWriter.merge.ALL`
Tools [#tools]
zoho_writer_list_documents [#zoho_writer_list_documents]
Writer list documents
zoho_writer_get_document [#zoho_writer_get_document]
Writer get document
zoho_writer_create_document [#zoho_writer_create_document]
Writer create document
zoho_writer_list_templates [#zoho_writer_list_templates]
Writer list templates
zoho_writer_merge_document [#zoho_writer_merge_document]
Writer merge document
zoho_writer_export_document [#zoho_writer_export_document]
Writer export document
Notes [#notes]
* Category: Productivity
* Authentication mode: OAuth
# Zoom Integration
The Zoom integration provides access to manage Zoom user profile and meetings through the Integrate MCP server.
Installation [#installation]
The Zoom integration is included with the SDK:
```typescript
import { zoomIntegration } from "integrate-sdk/server";
```
Setup [#setup]
1. Create a Zoom OAuth App [#1-create-a-zoom-oauth-app]
1. Create an OAuth application for Zoom
2. Configure your redirect URI
3. Note your Client ID and Client Secret
2. Configure the Integration on Your Server [#2-configure-the-integration-on-your-server]
Add the Zoom integration to your server configuration. The integration automatically reads `ZOOM_CLIENT_ID` and `ZOOM_CLIENT_SECRET` from your environment variables:
```typescript
import { createMCPServer, zoomIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
zoomIntegration({
}),
],
});
```
You can override the environment variables by passing explicit values:
```typescript
zoomIntegration({
clientId: process.env.CUSTOM_ZOOM_ID,
clientSecret: process.env.CUSTOM_ZOOM_SECRET,
});
```
3. Client-Side Usage [#3-client-side-usage]
The default client automatically includes all integrations. You can use it directly:
```typescript
import { client } from "integrate-sdk";
await client.authorize("zoom");
const result = await client.zoom.getUser({});
console.log(result);
```
If you're using a custom client, add the integration to the integrations array:
```typescript
import { createMCPClient, zoomIntegration } from "integrate-sdk";
const customClient = createMCPClient({
integrations: [zoomIntegration()],
});
```
Configuration Options [#configuration-options]
Tools [#tools]
zoom_get_user [#zoom_get_user]
Get user
zoom_list_meetings [#zoom_list_meetings]
List meetings
zoom_create_meeting [#zoom_create_meeting]
Create meeting
zoom_get_meeting [#zoom_get_meeting]
Get meeting
zoom_update_meeting [#zoom_update_meeting]
Update meeting
zoom_delete_meeting [#zoom_delete_meeting]
Delete meeting
Notes [#notes]
* Category: Communication
* Authentication mode: OAuth
# Elysia
The Integrate SDK provides seamless integration with Elysia through server-side configuration and route handlers. This guide assumes you have an Elysia project already set up.
Installation [#installation]
Install the Integrate SDK in your Elysia project:
```bash
bun add integrate-sdk
```
Setup [#setup]
Create a server configuration file with your OAuth credentials:
```typescript
// src/index.ts
import { Elysia } from "elysia";
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
import { cors } from "@elysiajs/cors";
const app = new Elysia();
const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
app.use(
cors({
origin: process.env.FRONTEND_URL || "http://localhost:3000",
credentials: true,
})
);
app.all("/api/integrate/*", (context) => {
return serverClient.handler(context.request);
});
app.listen(process.env.PORT || 8080);
console.log(`Server running on port ${process.env.PORT || 8080}`);
```
You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login).
Configuration [#configuration]
Add your OAuth credentials to your `.env` file:
```bash
INTEGRATE_API_KEY=your_integrate_api_key
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
FRONTEND_URL=http://localhost:3000
PORT=8080
```
CORS Setup [#cors-setup]
CORS is configured in the setup above. If you need to customize it, adjust the CORS middleware:
```typescript
app.use(
cors({
origin: process.env.FRONTEND_URL || "http://localhost:3000",
credentials: true,
})
);
```
Usage Examples [#usage-examples]
Client-Side Authorization [#client-side-authorization]
The client is automatically configured when making requests to the server.
```typescript
import { client } from "integrate-sdk";
await client.authorize("github");
```
# Express
The Integrate SDK provides seamless integration with Express through server-side configuration and route handlers. This guide assumes you have an Express project already set up.
Installation [#installation]
Install the Integrate SDK in your Express project:
```bash
bun add integrate-sdk
```
Setup [#setup]
Create a server configuration file with your OAuth credentials:
```typescript
// src/index.ts
import express from "express";
import {
createMCPServer,
githubIntegration,
} from "integrate-sdk/server";
import cors from "cors";
const app = express();
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
app.use(
cors({
origin: process.env.FRONTEND_URL || "http://localhost:3000",
credentials: true,
})
)
app.all("/api/integrate/*", (request: Request) => {
return serverClient.handler(request);
});
app.use(express.json());
app.listen(process.env.PORT || 8080, () => {
console.log(`Server running on port ${process.env.PORT || 8080}`);
});
```
Configuration [#configuration]
Add your OAuth credentials to your `.env` file:
```bash
INTEGRATE_API_KEY=your_integrate_api_key
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
FRONTEND_URL=http://localhost:3000
PORT=8080
```
You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login).
CORS Setup [#cors-setup]
CORS is configured in the setup above. If you need to customize it, adjust the CORS middleware:
```typescript
app.use(
cors({
origin: process.env.FRONTEND_URL || "http://localhost:3000",
credentials: true,
})
);
```
Usage Examples [#usage-examples]
Client-Side Authorization [#client-side-authorization]
The client is automatically configured when making requests to the server.
```typescript
import { client } from "integrate-sdk";
await client.authorize("github");
```
# Fastify
The Integrate SDK provides seamless integration with Fastify through server-side configuration and route handlers. This guide assumes you have a Fastify project already set up.
Installation [#installation]
Install the Integrate SDK in your Fastify project:
```bash
bun add integrate-sdk
```
Setup [#setup]
Create a server configuration file with your OAuth credentials:
```typescript
// src/index.ts
import Fastify from "fastify";
import cors from "@fastify/cors";
import {
createMCPServer,
githubIntegration,
} from "integrate-sdk/server";
const app = Fastify();
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
await app.register(cors, {
origin: process.env.FRONTEND_URL || "http://localhost:3000",
credentials: true,
});
app.route({
method: ["GET", "POST"],
url: "/api/integrate/*",
async handler(request, reply) {
try {
const url = new URL(request.url, `http://${request.headers.host}`);
const headers = new Headers();
Object.entries(request.headers).forEach(([key, value]) => {
if (value) headers.append(key, value.toString());
});
const req = new Request(url.toString(), {
method: request.method,
headers,
body: request.body ? JSON.stringify(request.body) : undefined,
});
const response = await serverClient.handler(req);
if (response) {
reply.status(response.status);
response.headers.forEach((value: string, key: string) => reply.header(key, value));
reply.send(response.body ? await response.text() : null);
} else {
reply.status(204).send();
}
} catch (error) {
reply.status(500).send({
error: "Internal integration error",
code: "INTEGRATION_FAILURE"
});
}
}
});
app.listen({ port: Number(process.env.PORT) || 8080 }, () => {
console.log(`Server running on port ${process.env.PORT || 8080}`);
});
```
Configuration [#configuration]
Add your OAuth credentials to your `.env` file:
```bash
INTEGRATE_API_KEY=your_integrate_api_key
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
FRONTEND_URL=http://localhost:3000
PORT=8080
```
You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login).
CORS Setup [#cors-setup]
CORS is configured in the setup above. If you need to customize it, adjust the CORS registration:
```typescript
await app.register(cors, {
origin: process.env.FRONTEND_URL || "http://localhost:3000",
credentials: true,
});
```
Usage Examples [#usage-examples]
Client-Side Authorization [#client-side-authorization]
The client is automatically configured when making requests to the server.
```typescript
import { client } from "integrate-sdk";
await client.authorize("github");
```
# Hono
The Integrate SDK provides seamless integration with Hono through server-side configuration and route handlers. This guide assumes you have a Hono project already set up.
Installation [#installation]
Install the Integrate SDK in your Hono project:
```bash
bun add integrate-sdk
```
Setup [#setup]
Create a server configuration file with your OAuth credentials:
```typescript
// src/index.ts
import { Hono } from 'hono'
import { cors } from 'hono/cors'
import { createMCPServer, githubIntegration } from 'integrate-sdk/server';
const app = new Hono()
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
app.use(
"/api/integrate/*",
cors({
origin: process.env.FRONTEND_URL || "http://localhost:3000",
credentials: true,
}),
);
app.on(["POST", "GET"], "/api/integrate/*", (c) => {
return serverClient.handler(c.req.raw);
});
export default app
```
You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login).
Configuration [#configuration]
Add your OAuth credentials to your `.env` file:
```bash
INTEGRATE_API_KEY=your_integrate_api_key
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
FRONTEND_URL=http://localhost:3000
PORT=8080
```
CORS Setup [#cors-setup]
CORS is configured in the setup above. If you need to customize it, adjust the CORS middleware:
```typescript
app.use(
"/api/integrate/*",
cors({
origin: process.env.FRONTEND_URL || "http://localhost:3000",
credentials: true,
})
);
```
Usage Examples [#usage-examples]
Client-Side Authorization [#client-side-authorization]
The client is automatically configured when making requests to the server.
```typescript
import { client } from "integrate-sdk";
await client.authorize("github");
```
# NestJS
The Integrate SDK provides seamless integration with NestJS through server-side configuration and controllers. This guide assumes you have a NestJS project already set up.
Installation [#installation]
Install the Integrate SDK in your NestJS project:
```bash
bun add integrate-sdk
```
Setup [#setup]
Server Configuration [#server-configuration]
Create a server configuration file with your OAuth credentials:
```typescript
// src/integrate.ts
import { createMCPServer, githubIntegration } from 'integrate-sdk/server';
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
scopes: ['repo', 'user'],
}),
],
});
```
You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login).
OAuth Controller [#oauth-controller]
Create a controller to handle OAuth routes:
```typescript
// src/oauth.controller.ts
import { Controller, All, Req, Res } from "@nestjs/common";
import type { Request, Response } from "express";
import { serverClient } from "./integrate";
@Controller("api/integrate")
export class OAuthController {
@All("*")
async handleOAuth(@Req() req: Request, @Res() res: Response) {
await serverClient.handler(req, res);
}
}
```
Register the controller in your module:
```typescript
// src/app.module.ts
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { OAuthController } from './oauth.controller';
@Module({
imports: [],
controllers: [AppController, OAuthController],
providers: [AppService],
})
export class AppModule { }
```
Configuration [#configuration]
Add your OAuth credentials to your `.env` file:
```bash
INTEGRATE_API_KEY=your_integrate_api_key
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
FRONTEND_URL=http://localhost:3000
PORT=8080
```
CORS Setup [#cors-setup]
Configure CORS in your `main.ts`:
```typescript
// src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
async function bootstrap() {
const app = await NestFactory.create(AppModule, {
bodyParser: false,
});
app.enableCors({
origin: process.env.FRONTEND_URL || "http://localhost:3000",
credentials: true,
});
await app.listen(process.env.PORT ?? 8080);
}
bootstrap().catch(console.error);
```
Usage Examples [#usage-examples]
Client-Side Authorization [#client-side-authorization]
The client is automatically configured when making requests to the server.
```typescript
import { client } from "integrate-sdk";
await client.authorize("github");
```
# Nitro
The Integrate SDK provides seamless integration with Nitro through server-side configuration and route handlers. This guide assumes you have a Nitro project already set up.
Installation [#installation]
Install the Integrate SDK in your Nitro project:
```bash
bun add integrate-sdk
```
Setup [#setup]
Create a server configuration file with your OAuth credentials:
```typescript
// server/routes/index.ts
import { defineEventHandler } from "h3"
import {
createMCPServer,
githubIntegration,
} from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
export default defineEventHandler(async (event) => {
return serverClient.handler(event.node.req);
});
```
You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login).
Configuration [#configuration]
Add your OAuth credentials to your `.env` file:
```bash
INTEGRATE_API_KEY=your_integrate_api_key
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
FRONTEND_URL=http://localhost:3000
PORT=8080
```
CORS Setup [#cors-setup]
Configure CORS using Nitro middleware:
```typescript
// server/middleware/cors.ts
import { defineEventHandler, setHeaders } from "h3";
export default defineEventHandler((event) => {
// Set CORS headers
setHeaders(event, {
"Access-Control-Allow-Origin": process.env.FRONTEND_URL || "http://localhost:3000",
"Access-Control-Allow-Methods": "GET, POST, OPTIONS",
"Access-Control-Allow-Headers": "Content-Type, Authorization",
"Access-Control-Allow-Credentials": "true",
});
// Handle preflight requests
if (event.node.req.method === "OPTIONS") {
return new Response(null, { status: 204 });
}
});
```
Usage Examples [#usage-examples]
Client-Side Authorization [#client-side-authorization]
The client is automatically configured when making requests to the server.
```typescript
import { client } from "integrate-sdk";
await client.authorize("github");
```
# Node.js
The Integrate SDK provides seamless integration with Node.js through server-side configuration and HTTP route handlers. This guide assumes you have a Node.js project already set up.
Installation [#installation]
Install the Integrate SDK in your Node.js project:
```bash
bun add integrate-sdk
```
Setup [#setup]
Create a server configuration file with your OAuth credentials:
```typescript
// index.ts
import { createServer } from "http";
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
createServer(async (req, res) => {
res.setHeader("Access-Control-Allow-Origin", process.env.FRONTEND_URL || "http://localhost:3000");
res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
res.setHeader("Access-Control-Allow-Credentials", "true");
if (req.method === "OPTIONS") {
res.statusCode = 204;
res.end();
return;
}
if (req.url?.startsWith("/api/integrate/")) {
await serverClient.handler(req);
} else {
res.statusCode = 404;
res.end("Not Found");
}
}).listen(process.env.PORT || 8080, () => {
console.log(`Server running on port ${process.env.PORT || 8080}`);
});
```
Configuration [#configuration]
Add your OAuth credentials to your `.env` file:
```bash
INTEGRATE_API_KEY=your_integrate_api_key
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
FRONTEND_URL=http://localhost:3000
PORT=8080
```
You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login).
CORS Setup [#cors-setup]
CORS is configured in the setup above. If you need to customize it, adjust the CORS headers:
```typescript
res.setHeader("Access-Control-Allow-Origin", process.env.FRONTEND_URL || "http://localhost:3000");
res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
res.setHeader("Access-Control-Allow-Credentials", "true");
```
Usage Examples [#usage-examples]
Client-Side Authorization [#client-side-authorization]
The client is automatically configured when making requests to the server.
```typescript
import { client } from "integrate-sdk";
await client.authorize("github");
```
Full Example [#full-example]
```typescript
// index.ts
import { createServer } from "http";
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
createServer(async (req, res) => {
res.setHeader("Access-Control-Allow-Origin", process.env.FRONTEND_URL || "http://localhost:3000");
res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
res.setHeader("Access-Control-Allow-Credentials", "true");
if (req.method === "OPTIONS") {
res.statusCode = 204;
res.end();
return;
}
if (req.url?.startsWith("/api/integrate/")) {
await serverClient.handler(req);
} else {
res.statusCode = 404;
res.end("Not Found");
}
}).listen(process.env.PORT || 8080, () => {
console.log(`Server running on port ${process.env.PORT || 8080}`);
});
```
# Astro
Installation [#installation]
Install the Integrate SDK in your Astro project:
```bash
bun add integrate-sdk
```
Setup [#setup]
1. Server Configuration [#1-server-configuration]
Create a server configuration file with your OAuth credentials:
```typescript
// lib/integrate.ts
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: import.meta.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
clientId: import.meta.env.GITHUB_CLIENT_ID,
clientSecret: import.meta.env.GITHUB_CLIENT_SECRET,
scopes: ["repo", "user"],
}),
],
});
```
You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login).
2. Mount the Handler [#2-mount-the-handler]
Create a catch-all API route at `pages/api/integrate/[...all].ts`:
```typescript
import { serverClient } from "@/lib/integrate";
import type { APIRoute } from "astro";
export const ALL: APIRoute = async (ctx) => {
return serverClient.handler(ctx.request);
};
```
Configuration [#configuration]
Add your OAuth credentials to your `.env` file:
```bash
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
```
Usage Examples [#usage-examples]
Client-Side Authorization [#client-side-authorization]
The client is automatically configured when making requests to the server.
```typescript
import { client } from "integrate-sdk";
await client.authorize("github");
```
# Next.js
The Integrate SDK provides seamless integration with Next.js through server-side configuration and catch-all route handlers. Set up OAuth in just 2 files.
Installation [#installation]
Install the Integrate SDK in your Next.js project:
```bash
bun add integrate-sdk
```
Setup [#setup]
Setting up OAuth in Next.js requires only **3 files**:
1. Server Configuration [#1-server-configuration]
Create a server configuration file with your OAuth credentials:
```typescript
// lib/integrate.ts
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
```
Next.js supports automatically importing the environment variables from the .env file.
You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login).
2. Mount the Handler [#2-mount-the-handler]
Create a single catch-all route that handles all OAuth operations at `app/api/integrate/[...all]/route.ts`
```typescript
import { serverClient } from "@/lib/integrate";
import { toNextJsHandler } from "integrate-sdk/server";
export const { POST, GET } = toNextJsHandler(serverClient);
```
Configuration [#configuration]
Add your OAuth credentials to your `.env` file:
```bash
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
```
Example [#example]
Clone the [Next.js example](https://github.com/integratedotdev/examples/tree/main/frameworks/frontend/nextjs-example) for a runnable project with GitHub OAuth and repo listing. Database-backed token storage examples live under [`database/`](https://github.com/integratedotdev/examples/tree/main/database) in the same repo.
Usage Examples [#usage-examples]
Client-Side Authorization [#client-side-authorization]
The client is automatically configured when making requests to the server.
```typescript
import { client } from "integrate-sdk";
await client.authorize("github");
```
# Nuxt
Installation [#installation]
Install the Integrate SDK in your Nuxt project:
```bash
bun add integrate-sdk
```
Setup [#setup]
1. Server Configuration [#1-server-configuration]
Create a server configuration file with your OAuth credentials:
```typescript
// lib/integrate.ts
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: import.meta.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
```
Nuxt supports automatically importing the environment variables from the .env file.
You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login).
2. Mount the Handler [#2-mount-the-handler]
Create a catch-all API route at `server/api/integrate/[...all].ts`:
```typescript
import { serverClient } from "~/lib/integrate";
export default defineEventHandler((event) => {
return serverClient.handler(toWebRequest(event));
});
```
Configuration [#configuration]
Add your OAuth credentials to your `.env` file:
```bash
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
```
Usage Examples [#usage-examples]
Client-Side Authorization [#client-side-authorization]
The client is automatically configured when making requests to the server.
```typescript
import { client } from "integrate-sdk";
await client.authorize("github");
```
# SolidStart
Installation [#installation]
Install the Integrate SDK in your SolidStart project:
```bash
bun add integrate-sdk
```
Setup [#setup]
1. Server Configuration [#1-server-configuration]
Create a server configuration file with your OAuth credentials:
```typescript
// lib/integrate.ts
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
```
SolidStart supports automatically importing the environment variables from the .env file.
You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login).
2. Mount the Handler [#2-mount-the-handler]
Create a catch-all API route at `routes/api/integrate/[...all].ts`:
```typescript
import { toSolidStartHandler } from "integrate-sdk/server";
import { serverClient } from "~/lib/integrate";
const handlers = toSolidStartHandler(serverClient);
export const { GET, POST, PATCH, PUT, DELETE } = handlers;
```
Configuration [#configuration]
Add your OAuth credentials to your `.env` file:
```bash
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
```
Usage Examples [#usage-examples]
Client-Side Authorization [#client-side-authorization]
The client is automatically configured when making requests to the server.
```typescript
import { client } from "integrate-sdk";
await client.authorize("github");
```
# SvelteKit
Installation [#installation]
Install the Integrate SDK in your SvelteKit project:
```bash
bun add integrate-sdk
```
Setup [#setup]
1. Server Configuration [#1-server-configuration]
Create a server configuration file with your OAuth credentials:
```typescript
// lib/integrate.ts
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
import {
INTEGRATE_API_KEY,
GITHUB_CLIENT_ID,
GITHUB_CLIENT_SECRET,
} from "$env/static/private";
export const { client: serverClient } = createMCPServer({
apiKey: INTEGRATE_API_KEY,
integrations: [
githubIntegration({
clientId: GITHUB_CLIENT_ID,
clientSecret: GITHUB_CLIENT_SECRET,
scopes: ["repo", "user"],
}),
],
});
```
You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login).
2. Mount the Handler [#2-mount-the-handler]
Create a catch-all API route at `routes/api/integrate/[...all]/+server.ts`:
```typescript
import { toSvelteKitHandler } from "integrate-sdk/server";
import { serverClient } from "$lib/integrate";
const svelteKitHandler = toSvelteKitHandler(serverClient);
export const POST = svelteKitHandler;
export const GET = svelteKitHandler;
```
Configuration [#configuration]
Add your OAuth credentials to your `.env` file:
```bash
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
```
Usage Examples [#usage-examples]
Client-Side Authorization [#client-side-authorization]
The client is automatically configured when making requests to the server.
```typescript
import { client } from "integrate-sdk";
await client.authorize("github");
```
# TanStack Start
Installation [#installation]
Install the Integrate SDK in your TanStack Start project:
```bash
bun add integrate-sdk
```
Setup [#setup]
1. Server Configuration [#1-server-configuration]
Create a server configuration file with your OAuth credentials:
```typescript
// lib/integrate.ts
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
```
TanStack Start supports automatically importing the environment variables from the .env file.
You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login).
2. Mount the Handler [#2-mount-the-handler]
Create a catch-all route at `routes/api/integrate/$.ts`:
```typescript
import { createFileRoute } from "@tanstack/react-router";
import { serverClient } from "@/lib/integrate";
export const Route = createFileRoute("/api/integrate/$")({
server: {
handlers: {
GET: ({ request }) => {
return serverClient.handler(request);
},
POST: ({ request }) => {
return serverClient.handler(request);
},
},
},
});
```
Configuration [#configuration]
Add your OAuth credentials to your `.env` file:
```bash
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
```
Usage Examples [#usage-examples]
Client-Side Authorization [#client-side-authorization]
The client is automatically configured when making requests to the server.
```typescript
import { client } from "integrate-sdk";
await client.authorize("github");
```
# Waku
Installation [#installation]
Install the Integrate SDK in your Waku project:
```bash
bun add integrate-sdk
```
Setup [#setup]
1. Server Configuration [#1-server-configuration]
Create a server configuration file with your OAuth credentials:
```typescript
// lib/integrate.ts
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
import { getEnv } from "waku";
export const { client: serverClient } = createMCPServer({
apiKey: getEnv("INTEGRATE_API_KEY")!,
integrations: [
githubIntegration({
clientId: getEnv("GITHUB_CLIENT_ID")!,
clientSecret: getEnv("GITHUB_CLIENT_SECRET")!,
scopes: ["repo", "user"],
}),
],
});
```
You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login).
2. Mount the Handler [#2-mount-the-handler]
Create a catch-all API route at `pages/api/integrate/[...route].ts`:
```typescript
import { serverClient } from "@/lib/integrate";
export const GET = serverClient.handler;
export const POST = serverClient.handler;
```
Configuration [#configuration]
Add your OAuth credentials to your `.env` file:
```bash
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
```
Usage Examples [#usage-examples]
Client-Side Authorization [#client-side-authorization]
The client is automatically configured when making requests to the server.
```typescript
import { client } from "integrate-sdk";
await client.authorize("github");
```
# Expo
Installation [#installation]
Install the Integrate SDK in your Expo project:
```bash
bun add integrate-sdk
```
Setup [#setup]
1. Server Configuration [#1-server-configuration]
Create a server configuration file with your OAuth credentials:
```typescript
// lib/integrate.ts
import { createMCPServer, githubIntegration } from "integrate-sdk/server";
export const { client: serverClient } = createMCPServer({
apiKey: process.env.INTEGRATE_API_KEY,
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
```
Expo supports automatically importing the environment variables from the .env file.
You can get an API key from the [Integrate Dashboard](https://integrate.dev/dashboard/login).
2. Mount the Handler [#2-mount-the-handler]
If using Expo's API Routes feature, create a catch-all route at `app/api/integrate/[...segments]+api.ts`:
```typescript
import { serverClient } from "@/lib/integrate";
export const GET = serverClient.handler;
export const POST = serverClient.handler;
```
Configuration [#configuration]
Add your OAuth credentials to your `.env` file:
```bash
GITHUB_CLIENT_ID=your_github_client_id
GITHUB_CLIENT_SECRET=your_github_client_secret
```
Server output [#server-output]
To make api routes work you need to set `web.output` to `server` in your `app.json` file.
```json
{
"expo": {
"web": {
"output": "server"
}
}
}
```
Deep Linking Setup [#deep-linking-setup]
Configure deep linking in your `app.json`:
```json
{
"expo": {
"scheme": "myapp",
"name": "My App"
}
}
```
Usage Examples [#usage-examples]
Client-Side Authorization [#client-side-authorization]
The client is automatically configured when making requests to the server.
```typescript
import { client } from "integrate-sdk";
await client.authorize("github");
```
Handling Deep Links [#handling-deep-links]
Set up deep link handling in your app:
```typescript
import * as Linking from "expo-linking";
import { useEffect } from "react";
export function OAuthCallback() {
useEffect(() => {
const handleUrl = ({ url }: { url: string }) => {
const { path, queryParams } = Linking.parse(url);
if (path === "oauth/callback") {
// Handle OAuth callback
console.log("OAuth callback:", queryParams);
}
};
Linking.addEventListener("url", handleUrl);
return () => {
Linking.removeEventListener("url", handleUrl);
};
}, []);
return null;
}
```
# Lynx
The Integrate SDK provides seamless integration with Lynx through client-side configuration. This guide assumes you have a Lynx project and a backend server running with the Integrate SDK configured (see the backend framework guides for setting up the server).
Installation [#installation]
Install the Integrate SDK in your Lynx project:
```bash
bun add integrate-sdk
```
Setup [#setup]
Create a client configuration file with your OAuth credentials:
```typescript
// src/lib/integrate.ts
import { createMCPClient, githubIntegration } from "integrate-sdk";
export const client = createMCPClient({
apiBaseUrl: "http://localhost:8080",
integrations: [
githubIntegration({
scopes: ["repo", "user"],
}),
],
});
```
Usage Examples [#usage-examples]
Client-Side Authorization [#client-side-authorization]
The client is automatically configured when making requests to the server.
```typescript
import { client } from "./lib/integrate";
await client.authorize("github");
```