Requires Claude Code installed and available in your terminal.

Set up Claude Code (Plugin)

Install the Atlan plugin with a single command, with no API keys, JSON, or manual MCP setup:

claude plugin install atlan@claude-plugins-official

When prompted, your browser opens the Atlan OAuth page. Sign in with your Atlan credentials, and the plugin's tools are ready to use in Claude Code.

Set up Claude Code (Manual)

OAuth
API key

Sign in with your Atlan account, using your own permissions.

In your terminal, add the OAuth-based Atlan MCP server:

claude mcp add --transport http atlan-oauth https://mcp.atlan.com/mcp

Start Claude Code:
```
claude
```
In the Claude Code terminal, type /mcp.
When prompted, complete the OAuth flow in your browser. The Atlan MCP server is then available in Claude Code.

Authenticate with a static API token, best for automation.

In Atlan, generate an API key from Admin Settings → API Keys / Tokens and copy it securely.

Add the API key-based Atlan MCP server:

claude mcp add-json atlan-api-key '{"type":"http","url":"https://mcp.atlan.com/mcp","headers":{"Authorization":"Bearer <API_KEY>"}}'

Start Claude Code with claude, type /mcp, and confirm the Atlan MCP server is listed and connected.

Requires OpenAI Codex (desktop app, CLI, or both).

Set up Codex (Plugin)

Register Atlan's marketplace with Codex:

codex plugin marketplace add https://github.com/atlanhq/agent-toolkit

Install the Atlan plugin:
```
codex plugin add atlan@atlan
```
The atlan@atlan slug follows Codex's <plugin-name>@<marketplace-name> convention.
Register the MCP server. This performs the actual registration and launches the OAuth flow with mcp.atlan.com, so complete the sign-in in your browser:
```
codex mcp add atlan --url https://mcp.atlan.com/mcp
```
Quit and relaunch Codex so the server loads (Cmd+Q for the desktop app, or restart the CLI). The plugin appears under Plugins → Manage.
Inside a Codex session, run /mcp to inspect connected servers, then ask anything Atlan-related.

Set up Codex (Manual)

OAuth runs automatically with mcp.atlan.com, so no API key is required.

Add the Atlan MCP server. This appends [mcp_servers.atlan] to ~/.codex/config.toml and launches the OAuth flow, so complete the sign-in in your browser:
```
codex mcp add atlan --url https://mcp.atlan.com/mcp
```
Exit and re-run the Codex CLI so the server loads, then run /mcp to verify it's connected.

Requires Cursor installed and updated to the latest version.

Set up Cursor (Plugin)

The plugin registers Atlan's hosted MCP server (https://mcp.atlan.com/mcp) with Cursor, with no API key or JSON editing required.

Install in one click:

Open in Cursor marketplace

Select Install on the marketplace page, then sign in on first use.

Or add it from inside Cursor:

Press Cmd+Shift+J (macOS) or Ctrl+Shift+J (Windows/Linux) to open settings, then go to Plugins.
Search for Atlan and click Install.
Open any chat and trigger an Atlan tool (for example, "search Atlan for the customers table"). On first use, Cursor opens the Atlan login page (SSO supported). After you log in, Cursor connects using your Atlan roles and permissions.
To verify, go to Features → Model Context Protocol in Cursor settings. The atlan server appears in the list.

note

The Atlan plugin lives in Cursor's plugin marketplace (used to register MCP servers and agents), not the extension marketplace in the sidebar.

Set up Cursor (Manual)

OAuth
API key

Sign in with your Atlan account, using your own permissions. Requires Cursor installed on this device.

Install in one click:

Add to Cursor

Or add it manually in Settings → Cursor Settings → Tools and Integration → New MCP Server:

{
  "mcpServers": {
    "atlan": {
      "type": "http",
      "url": "https://mcp.atlan.com/mcp"
    }
  }
}

After saving, Cursor prompts you to log in with your Atlan account (SSO supported), then connects using your roles and permissions.

Authenticate with a static API token, best for automation.

In Atlan, generate an API key under Admin Settings → API Keys / Tokens.

In Cursor, go to Settings → Cursor Settings → Tools and Integration, click New MCP Server, and add:

{
  "mcpServers": {
    "Atlan MCP Remote API Key": {
      "type": "http",
      "url": "https://mcp.atlan.com/mcp",
      "headers": {
        "Authorization": "Bearer <your-api-key>"
      }
    }
  }
}

Save the configuration. Cursor connects to Atlan with API key authentication.

Requires VS Code. The extension also works in Cursor and Windsurf via VSIX.

Set up VS Code (Extension)

Install the Atlan extension from the VS Code Marketplace, or open the Extensions view (Cmd+Shift+X / Ctrl+Shift+X), search for Atlan, and click Install.
Click the Atlan icon in the Activity Bar to open the sidebar.
Sign in with your Atlan workspace when prompted (SSO supported). To use an API key instead, open the Command Palette (Cmd+Shift+P / Ctrl+Shift+P) and run Atlan: Configure Connection (API Key).
The extension registers the Atlan MCP server automatically on first activation. To re-register later, run Atlan: Setup MCP Server.
Open GitHub Copilot Chat (or any MCP-aware assistant) and trigger an Atlan tool, for example: "search Atlan for the customers table".

Set up VS Code (Manual)

OAuth
API key

Sign in with your Atlan account, using your own permissions. Requires VS Code installed on this device.

Install in one click:

Install in VS Code

Or add it manually: open the Command Palette (Cmd+Shift+P / Ctrl+Shift+P), run MCP: Open User Configuration, and add this configuration to mcp.json:

{
  "servers": {
    "atlan-oauth": {
      "url": "https://mcp.atlan.com/mcp",
      "type": "http"
    }
  },
  "inputs": []
}

Save the file and click Start for MCP. A login prompt appears; after login, VS Code connects using your Atlan roles and permissions.

Authenticate with a static API token, best for automation.

In Atlan, generate an API key under Admin Settings → API access → Tokens.
Open the Command Palette (Cmd+Shift+P / Ctrl+Shift+P) and run MCP: Open User Configuration.

In the mcp.json file, add (replace <your-api-key> with your key):

{
  "servers": {
    "atlan-api-key": {
      "url": "https://mcp.atlan.com/mcp",
      "type": "http",
      "headers": {
        "Authorization": "Bearer <your-api-key>"
      }
    }
  },
  "inputs": []
}

Save the file and click Start for MCP. VS Code connects to Atlan with API key authentication.

Requires Windsurf. API key authentication only.

Set up Windsurf

In Atlan, generate an API key under Admin Settings → API Keys / Tokens and copy it securely.

In Windsurf, open the MCP configuration file and add:

{
  "mcpServers": {
    "Atlan MCP Remote": {
      "serverUrl": "https://mcp.atlan.com/mcp",
      "headers": {
        "Authorization": "Bearer <your-api-key>"
      }
    }
  }
}

Save the configuration. Windsurf is now connected to Atlan MCP with API key authentication.

An admin—or anyone with permission to add Databricks Marketplace connections—does this setup. You'll also need your Atlan domain and an Atlan OAuth client ID and secret. Generate the client under Settings (Admin) → API access → OAuth → Generate new → Generate OAuth Client. For more information, see OAuth clients.

Set up Databricks

In Databricks, open Marketplace, search for MCP, then select Atlan.
Select Install to open the wizard. Enter a Connection name and your Atlan OAuth client ID and client secret, then select Install.
Go to Catalog → Connect → Connections, select your Atlan MCP connection, and select Login.
Enter your Atlan domain name (the part before .atlan.com), select Sign in, and complete the Atlan sign-in flow. On the confirmation page, select Open in MCP Client to return to Databricks.
To verify, go to AI/ML → Playground, select Tools → Add tool → UC connection, choose your Atlan connection, and prompt the agent to find an asset or trace its lineage. You can review the server anytime under AI Gateway → MCPs.

Connect from the Snowflake UI so CoWork agents can use Atlan tools, or register the server with the Cortex Code CLI.

Set up Snowflake (CoWork agents)

Requires access to Agents settings in Snowflake CoWork.

note

The setup uses Dynamic Client Registration (DCR), so no OAuth client ID or secret is needed.

In Snowflake CoWork, go to Agents settings → Tools and connectors and select Add custom.
In the Add MCP Connector dialog, choose a Location and enter a Name (for example, Atlan) and a Description.
Under API Integration, select Dynamic Client Registration (DCR) and enter:
- Server URL: https://mcp.atlan.com/mcp
- Scopes: mcp
Select Add. When prompted, complete the OAuth sign-in with your Atlan account (SSO supported). The connector then uses your Atlan roles and permissions.
To verify, open a CoWork chat and ask an Atlan question, for example: "How many dashboards do I have in Atlan?" The agent answers using your governed Atlan metadata.

note

To use a pre-created OAuth client instead, select Standard OAuth in the dialog and supply the client ID, client secret, and endpoints from an Atlan OAuth client, generated under Settings (Admin) → API access → OAuth. For more information, see OAuth clients. For most teams, Dynamic Client Registration is the simpler path.

Set up Snowflake (Cortex CLI)

Requires Snowflake Cortex Code v1.0.61+ (check with cortex --version).

OAuth
API key

Add the OAuth-based Atlan MCP server. Cortex Code writes it to ~/.snowflake/cortex/mcp.json:
```
cortex mcp add atlan https://mcp.atlan.com/mcp --transport http
```
Start the MCP servers (or just start a cortex session, where configured servers initialize automatically):
```
cortex mcp start
```
When prompted, complete the OAuth flow in your browser. The token is stored under ~/.snowflake/cortex/mcp_oauth/.
Confirm the connection with cortex mcp list (outside a session) or /mcp (inside a session). On success, Cortex Code reports the connected server and tool count.

In Atlan, generate an API key under Admin Settings → API Keys / Tokens and copy it securely.
Add the API key-based server (replace <API_KEY> with your key). Cortex Code writes it to ~/.snowflake/cortex/mcp.json:
```
cortex mcp add atlan-api-key https://mcp.atlan.com/mcp --transport http -H "Authorization: Bearer <API_KEY>"
```
Start the MCP servers:
```
cortex mcp start
```
Because this uses a static token, it usually connects immediately. Confirm with cortex mcp list or /mcp.

tip

Pair Atlan's governance tools with Cortex Analyst: Cortex Analyst generates and runs the SQL, while Atlan supplies the certified definitions, ownership, and lineage that confirm you're querying the right data.

Requires a ChatGPT account and your Atlan domain. OAuth only.

Set up ChatGPT

Open in one click:

Open Atlan in ChatGPT

Or find it manually: in ChatGPT, go to Settings → Apps → Add more, search for Atlan, and select it.

Once the Atlan app is open, complete the sign-in:

Select Sign in with Atlan.
Enter your Atlan domain name (just the name, since the .atlan.com suffix is already added), then select Sign in:
```
your-tenant
```
Complete the OAuth login flow. ChatGPT redirects back and the Atlan app is ready to use.
Start using Atlan MCP tools in chat. For example:
```
show downstream assets for DIM_CUSTOMER
```

Atlan is an official connector in Claude's connector directory, so there's no custom setup—find Atlan in the directory and connect. This works the same on claude.ai and in the Claude Desktop app.

Set up Claude

How you add it depends on your plan:

Individual (Pro or Max)—you add Atlan yourself from the connector directory.
Team or Enterprise—an admin adds Atlan for the organization once, then each user connects and signs in.

Team / Enterprise
Individual (Pro/Max)

Not an admin? Request it.

On Team and Enterprise plans, only an admin can add the Atlan connector—but you don't have to wait. If Atlan isn't enabled for your organization yet, request it from your admin. Claude collects connector requests in the admin's Review requests → Feature requests queue, where they can enable Atlan in one click.

Admin (once):

Go to Organization settings → Connectors and select Browse connectors.
Find Atlan in the directory and select Add to your team. Atlan is now available to everyone in your organization.

Each user:

In Claude, open the + menu in the chat, hover Connectors, and select Manage connectors. Find Atlan and select Connect.
Complete the OAuth sign-in with your Atlan account. Once you're signed in, the connector runs with your own Atlan permissions.

No admin needed—you add Atlan yourself. This works on claude.ai and in the Claude Desktop app.

In Claude, select the + in the chat (or type /), hover Connectors, and select Manage connectors.
Select + to browse the directory, find Atlan, and select Connect.
Complete the OAuth sign-in with your Atlan account. The connector then runs with your own Atlan permissions.

Requires Node.js 18+. Install the CLI with npm install -g @google/gemini-cli, run gemini once to sign in, then add the config below to ~/.gemini/settings.json (create it with mkdir -p ~/.gemini && touch ~/.gemini/settings.json if it doesn't exist).

Set up Gemini CLI

OAuth
API key

Add (or merge) this into ~/.gemini/settings.json. Don't include headers or tokens, since Gemini handles the OAuth flow:

{
  "mcpServers": {
    "Atlan OAuth Server": {
      "httpUrl": "https://mcp.atlan.com/mcp",
      "oauth": {
        "enabled": true
      }
    }
  }
}

Save and restart Gemini CLI with gemini. The server appears but isn't authorized yet.
In your session, run /mcp auth Atlan OAuth Server. A browser window opens, where you sign in, and Gemini stores the tokens locally.
Verify with /mcp. The server shows as CONNECTED.

Generate an API key under Admin Settings → API Keys / Tokens.

Add (or merge) this into ~/.gemini/settings.json, replacing <atlan_api_key_here>:

{
  "mcpServers": {
    "Atlan API Key Server": {
      "httpUrl": "https://mcp.atlan.com/mcp",
      "headers": {
        "Authorization": "Bearer <atlan_api_key_here>"
      }
    }
  }
}

Save and restart Gemini CLI with gemini. Because this uses static headers, it usually works immediately. Verify with /mcp.

Glean acts as an MCP host. A Glean admin does the setup below, from Admin Console → Platform → Actions, with network reachability from Glean to the Atlan MCP endpoint. With OAuth User auth, each person then signs in with their own Atlan account the first time they use an Atlan tool in Glean.

Set up Glean

OAuth
API key

In Glean, go to Admin Console → Platform → Actions and select Import tools from MCP server.
Enter the connection details:
- MCP server name: a recognizable name, for example Atlan.
- MCP server URL: the OAuth endpoint https://mcp.atlan.com/mcp.
- Transport type: Streaming HTTP (or SSE if required).
- Authentication method: OAuth User, so each user authenticates with their own Atlan account. Glean supports PKCE.
Provide the OAuth configuration (authorization URL, token URL, client ID, scopes) from your Atlan tenant's OAuth settings. Glean doesn't support the client-credentials flow, so use an authorization-code (user) flow. If you're unsure of the values, contact Atlan Support.
Save the connection. Glean discovers the tools and makes them available to publish as actions. Publish the tools you want, applying role-based access for sensitive or write tools.

In Atlan, generate an API key under Admin Settings → API Keys / Tokens and copy it securely.
In Glean, go to Admin Console → Platform → Actions and select Import tools from MCP server.
Enter the connection details:
- MCP server name: a recognizable name, for example Atlan.
- MCP server URL: the hosted endpoint https://mcp.atlan.com/mcp.
- Transport type: Streaming HTTP (or SSE if required).
- Authentication method: API Key, with the header Authorization: Bearer <API_KEY>.
Save the connection, then publish the tools you want to expose.

OAuth only. Requires Node.js 18+ (for the mcp-remote bridge) and the Google ADK package (pip install google-adk for Python or npm install @google/adk for TypeScript).

Set up Google ADK

Python
TypeScript

Create an agent file (for example, agent.py):

from google.adk.agents import Agent
from google.adk.tools.mcp_tool import McpToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StdioConnectionParams
from mcp import StdioServerParameters

root_agent = Agent(
    model="gemini-flash-latest",
    name="atlan_agent",
    instruction="Help users search, explore, and govern data assets in Atlan",
    tools=[
        McpToolset(
            connection_params=StdioConnectionParams(
                server_params=StdioServerParameters(
                    command="npx",
                    args=[
                        "-y",
                        "mcp-remote",
                        "https://mcp.atlan.com/mcp",
                    ]
                ),
                timeout=30,
            ),
        )
    ],
)

Run your agent with adk run agent.py.
On first run, a browser window opens for OAuth approval. Sign in with your Atlan account. (If it doesn't open, copy the authorization URL printed in the terminal.) The agent then connects using your roles and permissions.

Create an agent file (for example, agent.ts):

import { LlmAgent, MCPToolset } from "@google/adk";

const rootAgent = new LlmAgent({
  model: "gemini-flash-latest",
  name: "atlan_agent",
  instruction: "Help users search, explore, and govern data assets in Atlan",
  tools: [
    new MCPToolset({
      type: "StdioConnectionParams",
      serverParams: {
        command: "npx",
        args: [
          "-y",
          "mcp-remote",
          "https://mcp.atlan.com/mcp",
        ],
      },
    }),
  ],
});

export { rootAgent };

Run your agent with adk run agent.ts.
On first run, a browser window opens for OAuth approval. Sign in with your Atlan account. (If it doesn't open, copy the authorization URL printed in the terminal.) The agent then connects using your roles and permissions.

Requires Microsoft Copilot Studio access with permissions to create agents and tools. A maker or admin builds the agent and adds Atlan as a tool; to share it, publish the agent to your organization, and end users then chat with the published agent.

Set up Microsoft Copilot Studio

OAuth
API key

In Copilot Studio, go to Agents, create a new agent (name and description), then select Create.
Open the agent, go to the Tools tab, and select New tool. In the wizard, select Model Context Protocol as the tool type.
Add a name and description, then set Server URL to:
```
https://mcp.atlan.com/mcp
```
Under Authentication, select OAuth 2.0, and for Type select Dynamic discovery. Copilot Studio registers the client and discovers the endpoints automatically, with no client ID, secret, or URLs needed. Select Create.
On Add tool, next to Connection, select Create new connection and sign in with your Atlan account. When the status shows Connected, select Add and configure.
Open the chat panel and run a query, such as Search for tables in Atlan.

note

If your first query returns a system error, run it again. The initial tool call can occasionally fail on the first attempt.

In Copilot Studio, go to Agents, create a new agent, then Create.
Open the agent, go to the Tools tab, select New tool, and choose Model Context Protocol as the tool type.
Add a name and description. For Authentication type, choose API key, and set the Server URL to:
```
https://mcp.atlan.com/mcp
```
For authentication type choose Header and set Header name to Authorization. Click Create.
Enter the Atlan API key you generated under Admin Settings → API Keys / Tokens, then click Create to finish adding the tool. Open the Chatbot panel and run a query.

Requires n8n. API key authentication only.

Set up n8n

n8n AI Agent node and LiteLLM

n8n doesn't include a native LiteLLM node for the Agent chat model. Community LiteLLM nodes may fail. If you need LiteLLM models, use the OpenAI Chat Model node with the Atlan gateway as the base URL and your Atlan API key.

In Atlan, generate an API key under Admin Settings → API Keys / Tokens.
In n8n, create a new Workflow and add an MCP Client node.
In the MCP Client node, choose the action List Tools to test the connection.
Under Credentials, select Create New Credentials and fill in:
- HTTP Stream URL: https://mcp.atlan.com/mcp
- HTTP Connection Timeout: 60000
- Additional Headers: Authorization = Bearer <your-api-key>
Save the credentials and execute the node with List Tools to see all MCP tools in your tenant. To run a tool, change Operation to Execute Tool, select the tool (for example, semantic_search), and fill in its parameters.

Run your own MCP gateway, proxy, or registry (for example, an internal gateway, an MCP-to-OpenAPI proxy, or an agent registry)? A gateway admin registers the Atlan MCP server once, and it's available to every downstream client that connects through the gateway. Requires admin access to your gateway and network reachability from the gateway to mcp.atlan.com. How end users authenticate depends on the method you choose below.

The key decision is how the gateway authenticates to Atlan, because the gateway becomes the identity boundary—Atlan sees the gateway, so what the gateway forwards determines each user's permissions and audit trail.

Set up Internal MCP gateway (OAuth passthrough)

Recommended for interactive, user-facing use. The gateway forwards each user's OAuth to Atlan, so every call runs with that user's own Atlan roles, and audit logs attribute calls to the real user.

In your gateway, register a remote MCP server:
- Server URL: https://mcp.atlan.com/mcp
- Transport: Streaming HTTP (or SSE if required)
- Authentication: OAuth, authorization-code (user) flow with PKCE. Atlan doesn't support the client-credentials flow for user identity.
Provide the OAuth configuration (authorization URL, token URL, client ID, scopes) from your Atlan tenant, generated under Settings (Admin) → API access → OAuth. For more information, see OAuth clients.
Expose the tools to your downstream clients. On first use, each user completes the Atlan sign-in, and the gateway reuses their token for later calls.

note

With OAuth passthrough, Atlan sees each end user's identity, so per-user permissions and per-user audit attribution are preserved.

Set up Atlan MCP

Set up Claude Code (Plugin)

Set up Claude Code (Manual)

Set up Codex (Plugin)

Set up Codex (Manual)

Set up Cursor (Plugin)

Set up Cursor (Manual)

Set up VS Code (Extension)

Set up VS Code (Manual)

Set up Windsurf

Set up Databricks

Set up Snowflake (CoWork agents)

Set up Snowflake (Cortex CLI)

Set up ChatGPT

Set up Claude

Set up Gemini CLI

Set up Glean

Set up Google ADK

Set up Microsoft Copilot Studio

Set up n8n

Set up Internal MCP gateway (OAuth passthrough)

Set up Internal MCP gateway (Service credential)

Next steps

Keeping your tools up to date

Need help?

Set up Claude Code (Plugin)

Set up Claude Code (Manual)

Set up Codex (Plugin)

Set up Codex (Manual)

Set up Cursor (Plugin)

Set up Cursor (Manual)

Set up VS Code (Extension)

Set up VS Code (Manual)

Set up Windsurf

Set up Databricks

Set up Snowflake (CoWork agents)

Set up Snowflake (Cortex CLI)

Set up ChatGPT

Set up Claude

Set up Gemini CLI

Set up Glean

Set up Google ADK

Set up Microsoft Copilot Studio

Set up n8n

Set up Internal MCP gateway (OAuth passthrough)

Set up Internal MCP gateway (Service credential)

Next steps​

Keeping your tools up to date​

Need help?​

Next steps

Keeping your tools up to date

Need help?