Airbyte MCP connector for AI agents

Tools your data agent reaches for on Airbyte, scoped per user.

CALL ANY TOOL

Manage data pipelines end to end: discover connector types, run credential flows, inspect sources, and query synced data.

airbytemcp_list_skills

List skills

List available skill documentation entries for connected data sources. Use this to discover docs skill IDs when you cannot call inspect_connector directly.

Parameters

Name

Type

Required

Description

cursor

string

Optional

Pagination cursor.

limit

integer

Optional

Maximum number of skills to return.

workspace_name

string

Optional

Optional workspace name.

airbytemcp_search_skills

Search skills

airbytemcp_list_workspaces

List workspaces

airbytemcp_get_current_workspace

Get current workspace

airbytemcp_list_organizations

List organizations

airbytemcp_get_connector_template

Get connector template

airbytemcp_list_created_connectors

List created connectors

airbytemcp_get_current_organization

Get current organization

airbytemcp_list_available_connectors

List available connectors

airbytemcp_execute

Execute

airbytemcp_use_workspace

Use workspace

airbytemcp_current_datetime

Current datetime

airbytemcp_use_organization

Use organization

airbytemcp_inspect_connector

Inspect connector

airbytemcp_read_skill_docs

Read skill docs

airbytemcp_start_credential_flow

Start credential flow

airbytemcp_execute_skill_function

Execute skill function

airbytemcp_check_enrollment_status

Check enrollment status

airbytemcp_delete_connector

Delete connector

airbytemcp_check_credential_flow_status

Check credential flow status

Build your Agent

Same auth pattern across LangChain, OpenAI, Anthropic, and Google ADK.

import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// Airbyte tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["airbytemcp"], toolNames: [
    "airbytemcp_list_created_connectors",
    "airbytemcp_inspect_connector",
    "airbytemcp_execute"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "Is the Salesforce sync healthy?" }] });

import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["airbytemcp"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "Which data sources are connected?" }],
  tools,
});

// Execute the tool call with the user's vaulted Airbyte credential
await sk.tools.executeTool(res.choices[0].message.tool_calls[0], "user_123");

import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["airbytemcp"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Pull open Zendesk tickets created this week." }],
  tools,
});

// Tool call runs with the user's vaulted Airbyte credential
await sk.tools.executeTool(msg.content, "user_123");

import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["airbytemcp"] }, pageSize: 100,
});

const agent = new Agent({
  name: "airbyte_data_agent",
  model: "gemini-2.5-pro",
  instruction: "Manage Airbyte pipelines for the signed-in user.",
  tools,
});

await agent.run("What auth does the Shopify connector need?");

Try these prompts

Copy any prompt into your agent. Each maps directly to an Airbyte tool. Click to copy, paste into your agent, done.

Pipeline health

Copy the prompt

Copied

Which data sources are connected right now?

Copy the prompt

Copied

Is the Salesforce sync healthy? When did it last run?

Copy the prompt

Copied

Inspect the Zendesk connector and flag any warnings.

Wire new sources

Copy the prompt

Copied

Connect a new Postgres source to the prod workspace.

Copy the prompt

Copied

What auth does the Shopify connector need?

Copy the prompt

Copied

Start a credential flow for HubSpot and send me the link.

Query synced data

Copy the prompt

Copied

Pull open Zendesk tickets created this week.

Copy the prompt

Copied

How many Salesforce opportunities closed this month?

Copy the prompt

Copied

Search Jira issues mentioning churn from the last sprint.

SEE HOW AUTH WORKS

Your users connect once. Their Airbyte credentials stay vaulted, every call is scope-checked, and every action is logged.

Authorize

Your user connects

Airbyte MCP

once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access

Who:

user ‘A’

when:

Once per user

access:

Limited to user

Store

Their

Airbyte MCP

token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection

vault:

encrypted

scope:

per-user

tokens:

auto-refreshed

Resolve

When your agent calls a

Airbyte MCP

tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs

speed:

~40ms

check:

before every call

seen by:

nobody

Audit

Every

Airbyte MCP

tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it

history:

90 days

export:

SIEM-ready

logged:

every call

Test other agents

See the same per-user auth pattern across other data connectors.

Engineering Teams

Slack triage

Polls Slack for new messages, classifies bugs and support requests with a LangGraph router, files GitHub issues or Zendesk tickets, and confirms in the thread.

Support and Ops Teams

Support ticket automation agent

Fetches new Zendesk tickets, drafts a reply from Notion knowledge base articles, digests what it cannot answer to Slack, and archives the rest, acting as the support agent rather than a shared API key.

Engineering Teams

DevOps assistant agent

Polls GitHub for failing checks and stale PRs, opens Linear issues for the ones that need work, and posts a daily digest to Slack. It acts as the engineer, not a shared service account.

Support and Ops Teams

Email-to-calendar agent

Reads scheduling intent out of Gmail threads, resolves the times everyone actually has free, and creates the event on the user's own Google Calendar. No shared service account.

Gmail

Google Calendar

View agent

Why Scalekit

Secure your agent's access. Connectors ship in minutes

01.

Shared tokens break per-user analytics

A shared Airbyte token looks fine in a demo. In production every pipeline change looks like one service account, and you cannot tell who wired a source or ran a query. Scalekit resolves the credential of the actual user who triggered the agent, never a shared bot.

// shared token
audit → bot_service_account

// scalekit
audit → user_abc ✓

02.

Authentication is not authorization

03.

Multi-tenancy is architectural

04.

Airbyte today. Ten connectors tomorrow.

“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”

Venu Madhav Kattagoni

Head of Engineering / Von

FAQs

Frequently Asked Questions

Does the agent access Airbyte as the user or through a shared key?

As the user. Scalekit resolves the credential of the person who triggered the agent at request time, so every pipeline change and query in your audit trail is attributed to a real user, not a shared service account.

Where is the Airbyte token stored?

In an AES-256 encrypted vault with per-tenant namespacing. Tokens are resolved at request time, never enter LLM context, refresh automatically, and can be revoked from one dashboard.

Can I limit what the agent does in Airbyte?

Yes. Filter by tool name in listScopedTools to expose only what you want, for example read-only inspection without execute or delete. Scalekit also enforces scope checks before every API call.

What happens when a user revokes access?

The credential is invalidated at the next tool call. The call fails closed, other users' connections are unaffected, and the revocation is logged in the audit chain.

How do agents pass source credentials like database passwords?

They never do. Airbyte's start_credential_flow returns a browser URL where the user enters secrets directly, and Scalekit vaults the resulting connection. Neither your agent nor the LLM ever sees a raw credential.

On this page

Tool and actions Framework Compatibility Starter Prompt Auth Lifecycle Try Other Agents Why Scalekit