---
title: "MCP Server - Xata"
description: "Connect Cursor, Claude, VS Code, and other MCP clients to Xata"
source: "https://xata.io/docs/platform/mcp"
---

Skip to main content

The Xata MCP server lets AI assistants and agents interact with your Xata organizations, projects, and branches using the [Model Context Protocol](https://modelcontextprotocol.io) (MCP).

## ​What is the Xata MCP server?

- A hosted MCP server that runs alongside the Xata API — there is nothing to install or run locally.
- Authenticated via OAuth in your browser, or with a Xata API key for headless environments.
- Accessible from any MCP client that supports remote servers over Streamable HTTP.

**Server URL:**

```
https://api.xata.tech/mcp
```

The server uses the **Streamable HTTP** transport. There is no SSE endpoint and no local (npm) version of the server.

## ​Authentication

The MCP server supports two authentication methods:

| Method  | Use when                          | Client requirement                                  |
| ------- | --------------------------------- | --------------------------------------------------- |
| OAuth   | Interactive use in an editor/chat | Support for MCP OAuth (dynamic client registration) |
| API key | Automation, CI, headless agents   | Support for custom HTTP headers                     |

### ​OAuth

With OAuth-capable clients, you only need the server URL. When your client connects for the first time, it registers itself with Xata, opens a browser window, and asks you to sign in to your Xata account and approve access. Tokens are short-lived and scoped to the MCP server.

### ​API key

Clients that support custom headers can authenticate with a [Xata API key](/docs/platform/api-key) instead:

```
Authorization: Bearer YOUR_XATA_API_KEY
```

Create a dedicated API key for MCP access rather than reusing an existing key. Store it in an environment variable or your client’s secret storage — never commit it to source control.

## ​Set up your MCP client

### ​Cursor

1. Open the command palette and search for “Cursor Settings”.
2. Under **Tools & MCP**, click **New MCP Server**.
3. Add the Xata server to the configuration file that opens:

.cursor/mcp.json

```
{
  "mcpServers": {
    "xata": {
      "url": "https://api.xata.tech/mcp"
    }
  }
}
```

4. Save the file. Cursor prompts you to authenticate — follow the browser flow and approve access to your Xata account.

### ​Claude Code

Add the server from your terminal:

```
claude mcp add --transport http xata https://api.xata.tech/mcp
```

Then start Claude Code and run the `/mcp` slash command. Select the `xata` server and follow the browser instructions to authenticate. To use an API key instead of OAuth (for example, in CI):

```
claude mcp add --transport http xata https://api.xata.tech/mcp
  --header "Authorization: Bearer YOUR_XATA_API_KEY"
```

### ​VS Code

MCP servers in VS Code require the [GitHub Copilot](https://marketplace.visualstudio.com/items?itemName=GitHub.copilot) and [GitHub Copilot Chat](https://marketplace.visualstudio.com/items?itemName=GitHub.copilot-chat) extensions.

1. Open the Command Palette (`Cmd+Shift+P` / `Ctrl+Shift+P`).
2. Run **MCP: Add Server** and choose **HTTP**.
3. Enter `https://api.xata.tech/mcp` as the URL and `xata` as the name.

Alternatively, add it to your configuration manually:

.vscode/mcp.json

```
{
  "servers": {
    "xata": {
      "type": "http",
      "url": "https://api.xata.tech/mcp"
    }
  }
}
```

Start the server from **MCP: List Servers** and allow it to authenticate when prompted.

### ​Claude (web and desktop)

Add Xata as a custom connector:

1. Go to **Settings** → **Connectors**.
2. Click **Add custom connector**.
3. Enter `https://api.xata.tech/mcp` as the server URL and click **Add**.
4. Follow the prompts to sign in with your Xata account.

Custom connectors using remote MCP are not available on all Claude plans, and may require an organization owner to add them on team plans. See the [Claude documentation](https://support.claude.com/en/articles/11175166-getting-started-with-custom-connectors-using-remote-mcp) for details.

### ​ChatGPT

Connect ChatGPT to Xata using a custom connector:

1. In ChatGPT, go to **Settings** → **Connectors** → **Advanced settings** and enable **Developer mode**.
2. On the Connectors tab, create a new connector with the server URL:

```
https://api.xata.tech/mcp
```

3. Choose **OAuth** for authentication and complete the authorization flow when prompted.
4. In each chat where you want to use Xata, click the **+** button and enable the Xata connector under **Add sources**.

### ​Codex CLI

Add the server from your terminal:

```
codex mcp add xata --url https://api.xata.tech/mcp
```

You should be prompted to authenticate — follow the instructions in the browser. Then start `codex` and run the `/mcp` slash command to confirm the server is enabled and authenticated.

### ​Gemini CLI

Add the server from your terminal:

```
gemini mcp add --transport http xata https://api.xata.tech/mcp
```

Then start `gemini` and authenticate:

```
/mcp auth xata
```

### ​OpenCode

Add the Xata server to your OpenCode configuration file:

~/.config/opencode/opencode.json

```
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "xata": {
      "type": "remote",
      "url": "https://api.xata.tech/mcp"
    }
  }
}
```

Then authenticate from your terminal:

```
opencode mcp auth xata
```

### ​Amp

Add the server from your terminal:

```
amp mcp add xata https://api.xata.tech/mcp
```

Then start `amp` — you should be prompted to authenticate in the browser. Run `/mcp list tools` to confirm the server is connected.

### ​Windsurf

1. In Windsurf, open the Cascade panel and click the MCP (hammer) icon, then **Configure** to open the raw configuration file (`~/.codeium/windsurf/mcp_config.json`).
2. Add the Xata server entry:

~/.codeium/windsurf/mcp_config.json

```
{
  "mcpServers": {
    "xata": {
      "serverUrl": "https://api.xata.tech/mcp"
    }
  }
}
```

3. Save the file and click **Refresh** in the Cascade sidebar. Complete the OAuth flow when the browser window opens.

### ​Zed

1. Open **Settings** → **AI** → **MCP Servers** and click **Add Server** → **Add Remote Server**, or edit your settings file directly:

settings.json

```
{
  "context_servers": {
    "xata": {
      "url": "https://api.xata.tech/mcp"
    }
  }
}
```

2. Zed prompts you to authenticate against the server using the standard MCP OAuth flow.

### ​Cline

1. Open Cline in VS Code and click the **MCP Servers** icon.
2. In the **Remote Servers** tab, enter `xata` as the name, `https://api.xata.tech/mcp` as the URL, and choose **Streamable HTTP** as the transport. Or edit the configuration JSON directly:

```
{
  "mcpServers": {
    "xata": {
      "type": "streamableHttp",
      "url": "https://api.xata.tech/mcp"
    }
  }
}
```

The transport type must be `streamableHttp` (camelCase). Omitting it causes Cline to fall back to the legacy SSE transport, which the Xata MCP server does not support.

### ​Other MCP clients

Any MCP client can connect if it supports:

- Remote MCP servers over **Streamable HTTP** (not SSE)
- **OAuth with dynamic client registration**, or **custom HTTP headers** for API key authentication

Consult your client’s documentation for where to configure remote MCP servers, and use `https://api.xata.tech/mcp` as the URL.

## ​Verify the connection

After connecting, ask your assistant:

> Use the Xata MCP server to tell me who I’m authenticated as.

The assistant should call the `user_info` tool and return your user identity (or the API key identity, if you authenticated with a key). If it does, the connection is working.

## ​Available tools

The Xata MCP server exposes the following tools:

| Tool                         | Description                                                                                             |
| ---------------------------- | ------------------------------------------------------------------------------------------------------- |
| `user_info`                  | Returns the identity of the authenticated caller — your user ID and email for OAuth, or the API key ID. |
| `search_operations`          | Find a Xata REST API operation by intent (for example, “list branches” or “invite member”).             |
| `describe_operation`         | Return the parameters and request/response schemas for a specific operation.                            |
| `call_operation`             | Invoke a Xata REST API operation. Operations that modify or delete resources require `confirm=true`.    |
| `run_sql`                    | Run SQL against a branch. Read-only by default; pass `write=true` to run statements that mutate data.   |
| `describe_schema`            | List the tables and columns of a branch.                                                                |
| `list_skills`                | List the available Xata skills — guided workflows for common multi-step tasks.                          |
| `get_skill`                  | Read the instructions for a specific skill.                                                             |
| `search_xata`                | Search the Xata documentation.                                                                          |
| `query_docs_filesystem_xata` | Read Xata documentation pages by path.                                                                  |

## ​Security

- Prefer OAuth for interactive clients; tokens are short-lived and can be revoked by disconnecting the server in your client.
- For automation, use a dedicated [API key](/docs/platform/api-key) and rotate it regularly.
- Some tools can modify your data: `call_operation` can change or delete resources (and requires `confirm=true` to do so), and `run_sql` can mutate data when called with `write=true`. Review the actions your assistant proposes before approving them, and keep a human in the loop for any write or delete.

## ​Troubleshooting

**Authentication keeps failing or loops.** Remove the Xata server from your client, restart the client, and add the server again to trigger a fresh OAuth flow. **The server connects but no tools show up.** Make sure you completed the authentication step — most tools require a valid session before they appear. Re-run your client’s authentication flow, then refresh its tool list. See Available tools for the full set. **Your client can’t connect at all.** Confirm the URL is exactly `https://api.xata.tech/mcp` and that your client supports Streamable HTTP. SSE-only clients are not supported. **The server doesn’t appear in your client.** Check the client’s MCP configuration file syntax — the JSON shape differs between clients (`mcpServers` vs `servers` vs `context_servers`, `url` vs `serverUrl`) — and check the client’s logs. Most clients require a full restart after configuration changes.

Was this page helpful?

[Previous](/docs/platform/api-key)

[Organizations](/docs/platform/organization)

[Next](/docs/platform/organization)