Guides8 min read

Best MCP Servers for Next.js Developers in 2026

The top MCP servers for Next.js development. Connect your AI to Vercel, Supabase, Stripe, Contentful, and more for full-stack Next.js workflows.

By MyMCPTools Team·

Next.js has become the dominant framework for full-stack React applications. With the App Router, server components, and built-in API routes, Next.js developers manage a complex stack spanning frontend, backend, database, and deployment — often simultaneously. MCP servers bridge your AI assistant to every layer of that stack.

Here are the MCP servers that matter most for Next.js development in 2026.

1. Vercel MCP Server — Deployment & Edge Config

Since most Next.js apps run on Vercel, the Vercel MCP server is a natural starting point. It gives your AI assistant visibility into deployment state, environment variables, edge config, and project settings.

What you can do:

  • Query deployment logs directly in your AI conversation
  • Check environment variable configuration across environments
  • Inspect edge config values and update them without leaving your editor
  • Review recent deployment failures and their error outputs

Best for: Teams that deploy to Vercel and want AI-assisted debugging of deployment issues and configuration drift.

2. Supabase MCP Server — Your Postgres Backend

Supabase is the most common backend choice for Next.js applications — it gives you PostgreSQL, auth, storage, and realtime in one package. The Supabase MCP server connects your AI to all of it.

Key capabilities:

  • Schema introspection — your AI understands your table structure
  • Row-level security policy inspection
  • Auth configuration and user management queries
  • Edge function management

With the Supabase MCP server, you can ask your AI to write a complex query and it will actually inspect your schema rather than making assumptions about column names and relationships.

3. Neon MCP Server — Serverless Postgres

Neon is the serverless PostgreSQL database purpose-built for Next.js and edge deployments. Its branching feature (separate database branches for PRs and staging) pairs perfectly with Next.js Preview Deployments. The Neon MCP server brings this into your AI workflow.

Unique capabilities:

  • Database branch management — create and delete branches like git branches
  • Schema diff between branches
  • Connection pooling configuration
  • Autoscaling status and compute usage

4. Stripe MCP Server — Payment Integration

Most SaaS apps built with Next.js use Stripe for billing. The Stripe MCP server allows your AI to inspect customer records, subscription states, and webhook configurations without requiring you to open the Stripe dashboard.

Useful for:

  • Debugging subscription webhook events
  • Looking up customer records while building billing features
  • Verifying price IDs and product configurations
  • Testing proration calculations and upgrade/downgrade logic

5. Contentful MCP Server — Content Management

Next.js content sites commonly use headless CMS platforms like Contentful. The Contentful MCP server gives your AI read access to your content models and entries, which is essential when writing GraphQL queries or building Next.js data-fetching functions that need to know the exact content structure.

6. Sanity MCP Server — Structured Content

Sanity is the other dominant headless CMS choice for Next.js. The Sanity MCP server provides schema introspection and content query capabilities, so your AI can write accurate GROQ queries without you having to manually describe the document structure.

7. Resend MCP Server — Transactional Email

Resend has become the go-to transactional email service for Next.js developers. The Resend MCP server lets your AI check email delivery logs, inspect template configurations, and debug email workflow issues.

8. GitHub MCP Server — Repository & PR Management

The GitHub MCP server is essential for Next.js teams — it closes the loop between your code changes and repository state. Your AI can check the current branch, review recent commits, and understand the context of the code it's working on.

9. Filesystem MCP Server — Local File Access

For local Next.js development, the Filesystem server gives your AI direct access to your project directory. This is especially useful in large monorepos where the AI needs to navigate multiple packages and understand the project's structure.

10. Cloudflare MCP Server — Edge & CDN

If you deploy Next.js to Cloudflare Pages or use Cloudflare's network (Workers, R2, KV), the Cloudflare MCP server provides configuration management and deployment visibility directly in your AI context.

Recommended Stack for Next.js Projects

Start lean and add as you encounter friction:

Project TypeEssential MCP Servers
SaaS AppFilesystem, GitHub, Supabase/Neon, Stripe, Vercel
Content SiteFilesystem, GitHub, Contentful/Sanity, Vercel
Marketing SiteFilesystem, GitHub, Vercel, Resend
MarketplaceFilesystem, GitHub, Supabase, Stripe, Cloudflare

Setting Up MCP Servers in Cursor for Next.js

Most Next.js developers use Cursor as their IDE. To add MCP servers:

  1. Open Cursor Settings → MCP
  2. Click "Add Server" and enter the server configuration
  3. Restart Cursor to load the new servers

Cursor's Composer and Chat modes both have access to your configured MCP servers. The Composer mode works particularly well for multi-file Next.js changes that span components, API routes, and data layers.

Browse all cloud MCP servers and database MCP servers for more Next.js-compatible options.

Recommended Tools

Better Stack

Free Plan

Get alerted when your APIs, browser tests, payment pipelines, or MCP server dependencies go down. Used by 100K+ developers.

Start monitoring free →

1Password

14-day Free Trial

Store and inject API keys, payment credentials, tokens, and file access secrets into your MCP server configs. Trusted by 150K+ developers.

Try 1Password free →

🔧 MCP Servers Mentioned in This Article

☁️

Vercel MCP Server

The Vercel MCP server is a powerful Model Context Protocol integration that allows AI assistants like Claude, Cursor, and Cline to interact directly with your Vercel infrastructure. It exposes essential platform capabilities as AI-callable tools, meaning you can manage projects, trigger deployments, inspect build logs, and configure custom domains via natural language prompts. For frontend developers and DevOps teams working within the Vercel ecosystem, this eliminates the need to constantly context-switch between an IDE, terminal, and the Vercel dashboard. You can simply ask your AI agent to "check the status of the latest production deployment", "fetch the build logs for the staging environment and identify the Next.js hydration error", or "list all environment variables for the current project". By bridging the gap between your codebase and your hosting platform, the Vercel MCP server turns your AI assistant into an embedded DevOps engineer capable of diagnosing build failures and managing serverless deployments in real time. Vercel ships this as an official hosted (remote) MCP server at https://mcp.vercel.com — there is no package to install locally. Connect an MCP client to that URL and authenticate through the browser-based OAuth flow, which scopes access to the Vercel teams and projects your account can already reach rather than a long-lived Personal Access Token. For example, add it to Claude Code with `claude mcp add --transport http vercel https://mcp.vercel.com`, then complete the OAuth consent screen; the repo vercel/vercel-mcp-overview is the official public overview of this server, with full docs at vercel.com/docs/mcp/vercel-mcp.

Auth required📘
🗄️

Supabase MCP Server

Supabase MCP Server connects Cursor, Claude Code, Claude Desktop, Windsurf and other MCP clients to a Supabase project, and the first thing to know is that the personal access token setup most guides still describe is gone. Supabase now runs a hosted server at https://mcp.supabase.com/mcp using OAuth 2.1 with dynamic client registration — you add the URL, your client opens a browser, you pick the organization, and there is no PAT to mint or rotate. For Claude Code that is `claude mcp add --scope project --transport http supabase "https://mcp.supabase.com/mcp"` followed by `/mcp` in a plain terminal (not the IDE extension) to run the auth flow. Three URL query parameters do the real configuration work: `read_only=true` runs every statement as a read-only Postgres role, `project_ref=<id>` scopes the server to one project and drops the account-management tools entirely, and `features=` selects the tool groups. Those groups are database (list_tables, list_extensions, list_migrations, apply_migration, execute_sql), debugging (get_logs across API/Postgres/Edge Functions/Auth/Storage/Realtime, plus get_advisors for security and performance findings), development (get_project_url, get_publishable_keys, generate_typescript_types), Edge Functions (list, get, deploy), account management, docs search, experimental branching on paid plans, and storage — storage is the one group disabled by default. Running Supabase locally with the CLI exposes a reduced server at http://localhost:54321/mcp with no OAuth; self-hosted installs are similar. The npm package `@supabase/mcp-server-supabase` still exists for stdio clients and also exports `createToolSchemas()` so Vercel AI SDK users get typed tool inputs and outputs. Read Supabase's security best-practices page before pointing this at anything with production data — the mutating tools are real.

Auth required📘
💰

Stripe MCP Server

The Stripe MCP server is Stripe's official Model Context Protocol integration, and the first thing to know is that it is not a package you install — it is a remote server Stripe hosts at https://mcp.stripe.com, and the documented connection mechanism is OAuth, not an API key. For Claude Code that is `claude mcp add --transport http stripe https://mcp.stripe.com/` followed by `claude /mcp` to complete consent; Cursor and VS Code take the bare URL, and ChatGPT accepts it as a custom connector on Pro, Plus, Business, Enterprise and Education accounts. An administrator has to enable MCP access in the Dashboard first, separately for sandbox and for live mode, which is the usual cause of a connection that refuses to authorise. Rather than one tool per endpoint, four generic tools carry most of the surface — stripe_api_search, stripe_api_details, stripe_api_read and stripe_api_write — so the tool schemas do not consume the context window, alongside dedicated create_refund, get_stripe_account_info, stripe_report, stripe_implementation_planner and search_stripe_documentation tools, plus a Treasury balance summary in public preview. Supported API methods span customers, charges, refunds, PaymentIntents, Checkout Sessions, invoices, subscriptions, coupons, promotion codes, products, prices, payment links, disputes, webhook endpoints, balance and balance transactions, payouts, tax settings and registrations, and Issuing. Clients that cannot do OAuth pass a restricted API key as a bearer token; Connect platforms acting as a connected account must use a restricted key plus a Stripe-Account header, since OAuth cannot express that. Sessions are revocable from Dashboard user settings under OAuth sessions, and Stripe recommends human confirmation of tools given prompt-injection risk.

Auth required📘
💻

Contentful

Enterprise headless CMS MCP for Contentful. Manage content types, entries, assets, and locales. Query and publish content across digital channels via AI.

Local
💻

Sanity CMS

Headless CMS MCP for Sanity. Query and mutate content using GROQ, manage datasets, import/export content, and work with Sanity's schema-driven data.

Auth required
💬

Resend MCP Server

The Resend MCP Server is Resend's official Model Context Protocol integration, letting AI assistants send and receive transactional email, manage contacts, broadcasts, and domains directly from Claude, Cursor, or any MCP-compatible client. Resend offers two ways to connect: a fully hosted remote server at mcp.resend.com (Streamable HTTP, no local install, OAuth login on first connect) that works well for Claude web/desktop and Cursor, or the same open-source code run locally via `npx resend-mcp` (published to npm as `resend-mcp`) using stdio or HTTP transport for CI, headless agents, or self-hosted setups. Authentication is either OAuth (hosted mode, browser-based) or a Resend API key passed as a Bearer token — handy for servers where a browser login isn't possible. Setup is documented for Claude Code, Claude Desktop/web, Cursor, Windsurf, Codex, and GitHub Copilot in VS Code. Typical use: ask Claude to "send a welcome email to this new signup using our verified domain" or "list contacts added to the newsletter audience this week," and the MCP server routes the request through your existing Resend account — no custom SMTP or REST integration code required. With 546+ GitHub stars, it's one of the most widely adopted first-party MCP servers in the email/transactional-messaging category.

Local
🗄️

Neon MCP Server

The Neon MCP Server (neondatabase/mcp-server-neon) is Neon's official, open-source bridge between natural language and the Neon serverless Postgres platform. It translates conversational requests into Neon API and SQL calls, letting Claude, Cursor, VS Code, and other MCP clients create projects and branches, run queries, inspect schemas, and perform database migrations without hand-writing SQL or hitting the API directly. A standout capability is migration support built on Neon's branching: the server can spin up a branch, apply and test a schema change there, and only then merge it — so an assistant can safely run "add a created_at column to the users table" against an isolated copy first. The easiest setup is the remote hosted server at https://mcp.neon.tech/mcp, which supports both OAuth (no API key to manage) and API-key auth via the Authorization header; run `npx neon@latest init` for one-command configuration of Cursor, VS Code (Copilot), and Claude Code, or `npx add-mcp https://mcp.neon.tech/mcp` to register it across all detected editors. Requires Node.js 18+ and a free Neon account; if IP Allow is enabled, whitelist the mcp.neon.tech static IPs. Neon explicitly scopes this server to local development and IDE workflows — its README warns against production use since natural-language commands can execute powerful, irreversible database operations, so always review actions before authorizing them.

Auth required📘
💻

GitHub MCP Server

authenticated access to the whole GitHub platform — repositories, files, branches, issues, pull requests, Actions runs, security alerts, discussions and notifications — from Claude, Cursor, VS Code, Copilot CLI and any other MCP host. There is no npm package for this server, and that trips up most people who try to install it: `@github/mcp-server` is not published to the npm registry, so any `npx` line you find for it will fail. GitHub ships it three other ways. The easiest is the hosted remote server at https://api.githubcopilot.com/mcp/, which needs no install at all — point an HTTP-transport MCP client at that URL and log in with OAuth (VS Code 1.101+, Claude Desktop, Claude Code, Cursor and Windsurf all support this). The second is the official Docker image ghcr.io/github/github-mcp-server, which is what the copy-paste command on this page runs; on github.com it now performs a browser-based OAuth login on first use and keeps the token in memory only, which is why the published Docker configs map a fixed loopback callback port (-p 127.0.0.1:8085:8085 with GITHUB_OAUTH_CALLBACK_PORT=8085) so the container can receive the callback. Prefer a token? Set GITHUB_PERSONAL_ACCESS_TOKEN instead — it takes precedence over OAuth, and the minimum useful scopes are repo, read:org and read:packages. The third is the native Go binary from the repository's releases, which needs no fixed port for the OAuth flow. GitHub Enterprise Server has no hosted option: use the local server with --gh-host or GITHUB_HOST set to your instance (include the https:// scheme — it defaults to http://, which GHES rejects). Toolsets can be narrowed with GITHUB_TOOLSETS, and an insiders channel is available at /mcp/insiders or via the X-MCP-Insiders header.

Auth required📘
📁

Filesystem MCP Server

sandboxed read, write, edit, move and search access to an explicit whitelist of local directories, and it is the reference implementation most other filesystem MCP servers are modelled on. Shipped by Anthropic in the official modelcontextprotocol/servers monorepo (89,000+ stars, actively maintained), it is a Node.js server published to npm as @modelcontextprotocol/server-filesystem. The part worth understanding before you install is the access-control model, because there are now two ways to grant directories and they do not compose. Method one is command-line arguments: `npx -y @modelcontextprotocol/server-filesystem /path/one /path/two`. Method two, and the one the maintainers recommend, is MCP Roots — a client that supports the roots protocol sends its roots at initialization, and those roots COMPLETELY REPLACE any directories passed on the command line, then get replaced again on every `notifications/roots/list_changed`. That means allowed directories can change at runtime without restarting the server, but it also means a roots-capable client silently overrides your CLI arguments. If the server starts with no arguments and the client either does not support roots or sends an empty list, initialization throws an error. The tool surface is broad: `read_text_file` (with mutually exclusive `head`/`tail` line windows), `read_media_file` returning base64 image/audio content blocks, `read_multiple_files` which keeps going when individual reads fail, `write_file`, `edit_file`, `create_directory`, `list_directory`, `list_directory_with_sizes`, `move_file`, `search_files`, `directory_tree`, `get_file_info` and `list_allowed_directories`. `edit_file` is the one to learn — it does line-based and multi-line pattern matching with indentation detection and preservation, returns a git-style diff with context, and supports `dryRun: true` so you can preview a change before applying it; the maintainers recommend always running a dry run first. Every operation is refused outside the allowed set, and `list_allowed_directories` is the fastest way to confirm what the server actually believes it can touch.

Local
☁️

Cloudflare MCP Server

Cloudflare ships two different things under this name. The mcp-server-cloudflare repo provides 16 remote, domain-specific MCP servers rather than one monolith — Documentation, Workers Bindings (storage/AI/compute primitives), Workers Builds, Observability (logs/analytics), Container sandboxes, Browser Rendering (fetch pages, convert to markdown, screenshots), Logpush health, AI Gateway (prompt/response search), AI Search, Audit Logs, DNS Analytics, Digital Experience Monitoring, Cloudflare One CASB, Radar, GraphQL analytics and the Agents SDK docs server, each on its own `*.mcp.cloudflare.com/mcp` hostname. Separately, the Cloudflare API MCP server at mcp.cloudflare.com/mcp (repo: cloudflare/mcp) exposes the whole 2,500+ endpoint Cloudflare API through just two tools, `search` and `execute`, using the Code Mode pattern — model-written JavaScript runs in an isolated Dynamic Worker, costing ~1,000 tokens of context against the ~1.17M an equivalent native-tool server would need. Pick a domain server when you want a readable, curated tool list for one product area; pick the API server for breadth or for endpoints nobody wrote a tool for. All endpoints are Streamable HTTP on `/mcp` and support the MCP 2026-07-28 spec; the historical `/sse` URLs remain as aliases for the same Streamable HTTP handler but no longer serve the deprecated HTTP+SSE transport, so clients pinned to SSE must switch. Auth is OAuth on connect, or a scoped Cloudflare API token as a bearer header for CI. Clients without native remote-MCP support bridge via `npx mcp-remote https://<subdomain>.mcp.cloudflare.com/mcp`.

Live📘

📚 More from the Blog