> ## Documentation Index
> Fetch the complete documentation index at: https://nango.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Coding agent setup

> Connect your coding agent to Nango

Coding agents can speed up Nango integration work in two places: wiring Nango into your product and building [Nango Functions](https://nango.dev/docs/guides/functions/functions-guide.md).

> [!NOTE]
>
> This page is about configuring Nango with your coding agent. To expose Nango integrations to your product's agents, see [Agent Sessions](https://nango.dev/docs/guides/agent-sessions.md).

## Management MCP server

Give your coding agent tools to manage your Nango account and search the Nango docs.

### OAuth (recommended)

OAuth authorization follows your Nango user permissions across the environments in your account. The Management MCP server uses Client ID Metadata Documents (CIMD) and doesn't support Dynamic Client Registration (DCR).

Refer to the [Management MCP reference](https://nango.dev/docs/reference/backend/management-mcp.md#tools) for the full tools list and required permissions.

> [tab] Claude Code
>
> Add the server for your user so it is available across projects:
>
> ```bash theme={null}
> claude mcp add --transport http nango-management --scope user https://mcp.nango.dev/mcp
> claude mcp login nango-management
> ```
>
> Complete the Nango authorization in the browser, then run `claude mcp list` to verify the connection.

> [tab] Codex
>
> Add the following to `~/.codex/config.toml` for a global configuration, or `.codex/config.toml` for a project configuration:
>
> ```toml theme={null}
> [mcp_servers.nango-management]
> url = "https://mcp.nango.dev/mcp"
> ```
>
> Start the OAuth flow:
>
> ```bash theme={null}
> codex mcp login nango-management
> ```
>
> Complete the Nango authorization in the browser, then use `/mcp` to verify the connection.

> [tab] VS Code
>
> Run **MCP: Open User Configuration** from the Command Palette, then add the server:
>
> ```json theme={null}
> {
>   "servers": {
>     "nangoManagement": {
>       "type": "http",
>       "url": "https://mcp.nango.dev/mcp"
>     }
>   }
> }
> ```
>
> Select **Start** above the server configuration. VS Code opens the Nango authorization page in your browser. Complete the authorization, then check that the server is running.

After connecting, ask the agent to call `environments_list`, then use one of the returned environment names for subsequent tool calls.

### API key

An Environment API key is useful for trusted clients when OAuth is not suitable, for example when the client does not support CIMD yet. Each key selects one environment, so these clients do not use `environments_list` or pass an `environment` argument. Create a key in **Environment Settings > API Keys**, replace `<NANGO-API-KEY>` in the relevant configuration below, and [limit its scopes](https://nango.dev/docs/reference/backend/management-mcp.md#use-an-api-key-instead) to the tools the client needs.

> [tab] Claude Code
>
> Add the server for your user so it is available across projects:
>
> ```bash theme={null}
> claude mcp add --transport http nango-management --scope user https://mcp.nango.dev/mcp \
>   --header "Authorization: Bearer <NANGO-API-KEY>"
> ```
>
> Run `claude mcp list` to verify the connection.

> [tab] Cursor
>
> Add the following to `~/.cursor/mcp.json` for a global configuration, or `.cursor/mcp.json` for a project configuration:
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "nango-management": {
>       "url": "https://mcp.nango.dev/mcp",
>       "headers": {
>         "Authorization": "Bearer <NANGO-API-KEY>"
>       }
>     }
>   }
> }
> ```
>
> Restart Cursor after saving the file.

> [tab] Codex
>
> Add the following to `~/.codex/config.toml` for a global configuration, or `.codex/config.toml` for a project configuration:
>
> ```toml theme={null}
> [mcp_servers.nango-management]
> url = "https://mcp.nango.dev/mcp"
> http_headers = { Authorization = "Bearer <NANGO-API-KEY>" }
> ```
>
> Restart Codex after saving the file, then use `/mcp` to verify the connection.

> [tab] VS Code
>
> Run **MCP: Open User Configuration** from the Command Palette, then add the server and a secure input for the API key:
>
> ```json theme={null}
> {
>   "inputs": [
>     {
>       "type": "promptString",
>       "id": "nango-api-key",
>       "description": "Nango API key",
>       "password": true
>     }
>   ],
>   "servers": {
>     "nangoManagement": {
>       "type": "http",
>       "url": "https://mcp.nango.dev/mcp",
>       "headers": {
>         "Authorization": "Bearer ${input:nango-api-key}"
>       }
>     }
>   }
> }
> ```
>
> VS Code prompts for the API key when it first starts the server and stores the value securely.

> [tab] Pi
>
> Pi does not include an MCP client, so first install the [`pi-mcp-adapter`](https://pi.dev/packages/pi-mcp-adapter) extension:
>
> ```bash theme={null}
> pi install npm:pi-mcp-adapter
> ```
>
> Then add the following to `~/.config/mcp/mcp.json` for a global configuration, or `.mcp.json` for a project configuration:
>
> ```json theme={null}
> {
>   "mcpServers": {
>     "nango-management": {
>       "url": "https://mcp.nango.dev/mcp",
>       "headers": {
>         "Authorization": "Bearer <NANGO-API-KEY>"
>       }
>     }
>   }
> }
> ```
>
> Restart Pi after installing the extension, then use `/mcp` to verify the connection.

> [tab] OpenCode
>
> Add the following to `~/.config/opencode/opencode.json` for a global configuration, or `opencode.json` in a project root for a project configuration:
>
> ```json theme={null}
> {
>   "$schema": "https://opencode.ai/config.json",
>   "mcp": {
>     "nango-management": {
>       "type": "remote",
>       "url": "https://mcp.nango.dev/mcp",
>       "oauth": false,
>       "headers": {
>         "Authorization": "Bearer <NANGO-API-KEY>"
>       },
>       "enabled": true
>     }
>   }
> }
> ```
>
> Run `opencode mcp list` to verify the connection.

> [!WARNING]
>
> Do not commit API keys to source control. Prefer user-level configuration when storing an API key inline.

## Skills

Nango's public skills live in [NangoHQ/skills](https://github.com/NangoHQ/skills).

Install the core skill to implement Nango integration functions:

```bash theme={null}
npx skills add NangoHQ/skills -s building-nango-functions
```

See the [functions guide](https://nango.dev/docs/guides/functions/functions-guide.md) for more details.

## Docs MCP server

If your coding agent only needs documentation, connect it directly to Mintlify's public Nango documentation MCP server:

```text theme={null}
https://nango.dev/docs/mcp
```

> [!NOTE]
>
> This is an unauthenticated alternative to the documentation tools included in the Management MCP server. If you use the Management MCP, you can skip this one.

## Just-in-time integrations

Nango integrations are defined as code. Usually, you or your coding agent write functions in a Git repo, review them like application code, and deploy them to Nango.

Nango also exposes a Functions API for creating integrations just in time, without asking the user to interact with a codebase. A user can describe the integration behavior in text, and an agent can turn that into function code, compile it, dry run it against a connection, and deploy it directly to Nango.

This is useful for faster onboarding, prototypes, and dynamic product experiences where integration behavior depends on what the user needs at that moment. It blurs the line between creating and consuming integrations: at consumption time, an agent can define the behavior, validate it, and make it available through Nango. See [build with the Functions API](https://nango.dev/docs/guides/functions/functions-guide.md#build-with-the-functions-api) for the workflow and API references.

## Other agent tools

These resources help agents discover Nango docs, provider slugs, API shapes, and runtime tool-calling paths.

| Tool | URL | Use it for |
| - | - | - |
| Docs MCP server | `https://nango.dev/docs/mcp` | Live docs context without authentication. |
| `llms.txt` | `https://nango.dev/docs/llms.txt` | Compact index of core Nango docs for LLM context windows. |
| `llms-full.txt` | `https://nango.dev/docs/llms-full.txt` | Full generated docs text for deeper offline context. |
| `api-catalog.txt` | `https://nango.dev/docs/api-catalog.txt` | Provider and integration slug discovery. |
| OpenAPI spec | `https://nango.dev/docs/spec.yaml` | Exact HTTP API schemas for code generation or typed clients. |


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.