AppConnect SDKPrivate Beta

Give your agent every app your users already use.

Authenticated tool access in code, on behalf of your users. AppConnect runs the OAuth flows, refreshes the tokens, and keeps credentials encrypted, so your agent only has to decide what to do.

Request private-beta accessRead the docs

Diagram: your agent’s code calls the AppConnect SDK, which handles OAuth, token refresh, and encrypted credentials, and runs the call against services the user connected through a hosted Link, such as Google Calendar, Slack, and GitHub.

Services in the catalog
960+
Tools your agent can call
9,000+
Trigger types
10
SDKs: TypeScript + Python
2
SDK, MCP, and Link

One connection layer, three ways in.

Use the SDK when you’re working in code or building AppConnect into your product. Use MCP to expose the same connections to AI apps that can’t run code. Link is how your users connect their apps in the first place.

SDK

Your code calls the tools

Use the TypeScript or Python SDK when you are writing code or building connected services into your own product. Your backend, your agent loop, your framework.

MCP

AI apps call the tools

Use the MCP endpoint to give connected services to AI clients such as Claude, ChatGPT, or Cursor that can't run your code.

Link

Your users connect their apps

A hosted connect flow you open from the SDK. Users authorize each provider on the provider's own screen and land back in your app.

Who it’s for

Built for builders and their agents.

The same interface works whether you write the integration yourself or hand the job to a coding agent.

AI builders: ship the integration in an afternoon.

Already working in Claude Code, Cursor, or Codex? Point your agent at the AppConnect agent skill and it wires up hosted Link, the token exchange, and a first tool call using your repo’s own conventions.

Starter prompt for your coding agent

Add [service names] integrations to my product using AppConnect Platform mode. Read https://www.appconnecthq.com/.well-known/agent-skills/appconnect-platform-sdk/SKILL.md first. Implement hosted Link with credentials and token exchange kept on the backend, then verify one successful read-only provider operation.

Browse all agent skills

Product teams: skip the auth plumbing.

Let your users connect Google, Slack, GitHub, and more from inside your product. You create a Link session and store the tokens you get back. Consent screens, callbacks, and refresh are handled for you.

Automation builders: react to events.

Subscribe to provider events such as new commits or calendar changes and receive signed webhook deliveries you can verify with one SDK call.

How it works

From install to first tool call, in three steps.

  1. 01

    Install and initialize

    Add the TypeScript or Python SDK to your backend and create a client with your partner credentials. The secret stays on your server.

  2. 02

    Connect your users once

    Create a Link session, send the user to it, and exchange it when they return. They authorize on the provider's own consent screen, and tokens are refreshed for you after that.

  3. 03

    Your agent takes action

    Search or list the tools that user has access to, hand them to your model, and execute whatever it calls, all scoped to that user's connections.

// Server-side only: the client secret never ships to browsers or apps.
import { AppConnectClient } from "@appconnecthq/sdk";

const client = new AppConnectClient({
  clientId: process.env.APPCONNECT_CLIENT_ID!,
  clientSecret: process.env.APPCONNECT_CLIENT_SECRET!,
});
Framework adapters

Bring the framework you already use.

One call turns a user’s connected tools into the shape your framework expects, and a second executes whatever the model decides to call.

  • OpenAI and Anthropic: TypeScript and Python, no extra dependencies
  • Vercel AI SDK: TypeScript, via @appconnecthq/sdk/ai-sdk
  • LangChain: TypeScript and Python, as an opt-in extra
import { toOpenAITools, executeOpenAIToolCall } from "@appconnecthq/sdk";

const tools = await toOpenAITools({ client, accessToken });
const reply = await openai.chat.completions.create({
  model: "gpt-4o-mini",
  messages,
  tools,
});

for (const call of reply.choices[0].message.tool_calls ?? []) {
  messages.push(await executeOpenAIToolCall({ client, accessToken }, call));
}
What we run

Everything we handle.
Nothing you maintain.

Build on the surfaces you and your agent already use. The hard parts of integrations run underneath.

9,000+ tools across 960+ servicesTyped tool definitions with JSON Schema inputs, searchable per user.
Auth managed for every connectionOAuth flows, callbacks, and token refresh, plus API-key and credential-form services.
Your OAuth app or oursCredentials resolve per user, then per partner, then platform defaults.
Raw API proxyNo prebuilt tool yet? client.proxy() makes an authenticated call to the provider API.
Encrypted at restConnection credentials are stored with AES-256-GCM, and secrets stay server-side.
Triggers with delivery historyHMAC-signed webhook deliveries, with every attempt recorded and queryable.
Triggers

Don’t poll. Get told.

Subscribe to provider events for a connected user. AppConnect delivers each one to your endpoint with an HMAC signature, and the SDK verifies it in one call.

subscribe + verify
import { verifyWebhookSignature } from "@appconnecthq/sdk";

const { signing_secret } = await client.subscribeTrigger(accessToken, {
  service: "github-oauth",
  trigger: "new_commit",
  config: { owner: "acme", repo: "api" },
  callbackUrl: "https://yourapp.com/webhooks/appconnect",
});
// Store signing_secret: it is returned only once.

// Later, in your webhook handler:
const valid = verifyWebhookSignature(
  rawBody,
  request.headers.get("x-appconnect-signature") ?? "",
  signingSecret,
);
Private Beta

Available to private-beta partners.

We’re onboarding a limited number of teams. Tell us what you’re building and we’ll set up your partner credentials. Pricing isn’t published yet.

Request access
  • TypeScript SDK (@appconnecthq/sdk)
  • Python SDK (appconnect)
  • Hosted Link for your users
  • MCP endpoint for AI clients
  • Triggers and signed webhooks
FAQ

Questions, answered.

A server-side SDK for TypeScript and Python that gives your code and your agents authenticated access to the services your users connect. It creates hosted Link sessions, lists and executes tools on a user's behalf, proxies raw API calls, and manages triggers.
Teams adding integrations to their own product, developers building AI agents that act for their users, and builders who want a coding agent to wire the integration for them.
Yes. Adapters turn a user's tools into OpenAI, Anthropic, Vercel AI SDK, or LangChain tool definitions and execute the calls the model makes. A coding agent can also set the integration up for you from the published agent skill.
Both reach the same connections. Use the SDK when you control the code. Use MCP to give connected services to AI clients such as Claude, ChatGPT, or Cursor that can't run your code.
No. Users authorize through hosted Link on each provider's own consent screen. AppConnect stores the credentials encrypted and refreshes tokens. Your backend keeps only the AppConnect access token for that user.
On your server. The SDK is server-side: your client secret, AppConnect tokens, and provider tokens should never ship in a browser or mobile bundle. Mobile apps open hosted Link in the system browser, and your backend handles the exchange.
Use client.proxy() to make an authenticated call straight to the provider's API with the user's connection, or ask us about adding the tool.
The SDK is in private beta and pricing isn't published yet. Request access to discuss your use case.
AppConnect SDK

Your agent. Your users’ apps.
AppConnect handles the keys.

One interface for your code and your agents. You write the logic, and we keep the connections working.

Request private-beta accessBrowse integrations