Snowflake MCP Server Cursor IDE Setup (2026)

Key Takeaways

Why This Is Different From a Typical Database MCP Setup

Most database MCP servers on this site — MySQL, PostgreSQL — follow the same shape: install a local npx-run process, point it at connection credentials in an env block, done. Snowflake's setup diverges because Snowflake now runs the MCP server itself, inside your account, and exposes it as an HTTP endpoint rather than something you spin up locally. You're not installing a server; you're pointing Cursor at one Snowflake already runs for you.

This also means the setup below uses Cursor's Streamable HTTP transport support rather than the command/args pattern used by most guides on this site. If your Cursor version predates HTTP-based MCP servers, this integration won't work until you update.

Snowflake-Managed MCP vs. the Old Community Server

If you find an older tutorial referencing Snowflake-Labs/mcp with an npx install and a SNOWFLAKE_ACCOUNT / SNOWFLAKE_PASSWORD env block, it's describing the community project Snowflake is retiring in favor of the account-native version:

| | Community Snowflake-Labs/mcp (deprecated) | Snowflake-managed MCP (current) |
|---|---|---|
| Where it runs | Locally, via npx | Inside your Snowflake account |
| Auth | Username/password or key-pair in env | Programmatic Access Token scoped to a role |
| Transport | stdio (local process) | HTTP endpoint |
| Maintenance | Community-maintained, being sunset | Maintained by Snowflake directly |
| Tool surface | Basic SQL execution | SQL execution, Cortex Search, Cortex Analyst, Cortex Agents |

If a setup guide you're reading doesn't mention Programmatic Access Tokens or an account-specific URL, assume it's describing the deprecated path and check Snowflake's current docs before following it.

What You Get Beyond Raw SQL

The managed server's tool surface goes further than "run a query and return rows":

Cortex Search and Cortex Analyst are not zero-config — they require you to have already built a search service or a semantic model in Snowflake. If neither exists in your account yet, you'll effectively be limited to raw SQL execution through MCP until someone sets those up, regardless of what the marketing material implies about natural-language querying.

Prerequisites

Generating a Programmatic Access Token

1. In Snowsight, go to Settings → Authentication → Programmatic Access Tokens
2. Click to create a new token
3. Scope it to a specific role — don't generate a PAT tied to a broad admin role for something an AI assistant will be calling. Create (or reuse) a role with read access limited to the schemas you actually want queryable.
4. Set an expiration date. PATs support expiry; treat this the same way you'd treat a rotated API key elsewhere and don't set it to "never."
5. Copy the token value immediately — it's shown once.

Finding Your MCP Endpoint URL

The managed server is exposed per-database/schema at a URL following this pattern:

https://<account_identifier>.snowflakecomputing.com/api/v2/databases/<database>/schemas/<schema>/mcp-servers/<server_name>

Check Snowsight's MCP servers page under your target database and schema for the exact URL Snowflake generates for your account — the path structure has changed before as this feature has matured, so treat the pattern above as a starting point to confirm against, not a value to copy verbatim.

Configuring Cursor

Add an HTTP-based entry to ~/.cursor/mcp.json:

{
  "mcpServers": {
    "snowflake": {
      "url": "https://your_account.snowflakecomputing.com/api/v2/databases/ANALYTICS/schemas/PUBLIC/mcp-servers/default",
      "headers": {
        "Authorization": "Bearer YOUR_PROGRAMMATIC_ACCESS_TOKEN"
      }
    }
  }
}

Restart Cursor, then check View → Output → MCP to confirm the connection authenticated. Test with something read-only and cheap:

List the tables in the PUBLIC schema of the ANALYTICS database

If that returns real table names, the connection and the PAT's role permissions are both working.

The Cost Problem Nobody Mentions in the Quick-Start Docs

Every tool call against Snowflake — even a SELECT COUNT(*) — resumes a warehouse if it's suspended and burns compute credits while running. An AI iterating on a query ("let me also check this," "let me also check that") can rack up a surprising number of warehouse-seconds in a single chat session, and unlike a human, it won't necessarily notice or care that it just scanned a multi-terabyte table three times in a row.

Two things reduce the blast radius:

Neither of these is enforced by the MCP server itself — they're Snowflake account configuration, done once, that make the integration safe to leave running.

Troubleshooting

Connection fails with a 401 or 403
Check that the PAT hasn't expired and that it was pasted into the Authorization: Bearer header correctly, with no extra whitespace. A 403 specifically (as opposed to 401) usually means the token is valid but the role lacks a grant on the resource you're querying.

"Warehouse not found" or query hangs
Confirm the role has USAGE on a warehouse, not just on the database and schema. A role can see table metadata without being able to actually run a query if the warehouse grant is missing.

Cortex Analyst returns "no semantic model found"
This tool requires a semantic model to already exist in your account. It's not a fallback for general schema questions — for those, ask the AI to run a DESCRIBE or query INFORMATION_SCHEMA directly instead.

Setup instructions found online don't match what's in Snowsight
You're likely looking at documentation for the deprecated Snowflake-Labs/mcp community server. Check whether the guide mentions an npx install and a username/password — if so, it predates the managed server and the steps in this guide supersede it.

Cursor doesn't recognize the url field in mcp.json
Your Cursor version may predate HTTP/remote MCP server support. Update Cursor, or check its MCP settings documentation for the current expected format for remote servers — client-side support for this transport has evolved faster than most integration guides keep up with.

Frequently Asked Questions

Q: Do I still need to install anything locally, the way most MCP servers require an npx package?
A: No. The managed Snowflake MCP server runs inside your Snowflake account and is exposed as an HTTP endpoint. Your mcp.json entry just needs a URL and an Authorization header — there's no local process for Cursor to spawn.

Q: Is querying production Snowflake data through an AI assistant safe?
A: It's as safe as the role you attach to the PAT. Row-level security policies, column masking, and object-level grants all apply through MCP exactly as they do for any other client using that role — the AI can't see more than the role can. The actual risk isn't data exposure beyond the role's normal access; it's uncontrolled compute cost from unscoped queries, which is a separate problem worth solving with a dedicated warehouse.

Q: How much could this cost me if I'm not careful?
A: It scales with warehouse size and how long queries run, the same as any other Snowflake workload. A dedicated small warehouse with a short auto-suspend window keeps idle cost near zero; the risk is a single chat session where the AI runs several full-table scans against a large warehouse without you noticing until the bill arrives.

Q: What happened to the old Snowflake-Labs MCP server I found in an older tutorial?
A: It's being deprecated in favor of the account-managed version described in this guide. If you're setting this up for the first time, skip the community package entirely and use the managed server — there's no reason to build on something already scheduled for removal.

Q: Can I use this with Cortex Analyst for natural-language business questions, or only raw SQL?
A: Both, but Cortex Analyst requires a semantic model to already exist in your account — someone has to define how business terms map to your actual tables before the AI can answer natural-language questions reliably. Without that setup, you're working with the SQL execution tool and Snowflake's standard schema metadata, which is still useful but closer to a normal database MCP experience than the "ask it anything" pitch implies.

Related Guides

---