Most Popular MCP Servers for Cursor

Short answer: Start with the MCP server that matches the work you do most often. Context7 is the documentation choice, GitHub is the repository choice, and Playwright is the browser-testing choice. Figma, Notion, and Linear support product workflows; Supabase and Sentry support backend and debugging work; Firecrawl and Stripe cover web research and payments.

There is no authoritative install-count leaderboard for these servers. “Popular” here means prominent servers currently listed in Cursor’s curated directory, not a quantified ranking.

What MCP adds to Cursor

Model Context Protocol (MCP) connects Cursor to external tools and data sources. Instead of repeatedly explaining your project structure or copying information into chat, Cursor can call approved tools and read the systems you already use.

Cursor supports one-click Marketplace installation, project-level .cursor/mcp.json, and global ~/.cursor/mcp.json configuration. Local servers commonly use command, args, and env. Remote servers use a url plus headers or OAuth.

The 10 MCP servers to know

Server	Best fit	Typical work	Watch before installing
Context7	Current documentation	Look up library and framework APIs while coding	Verify that retrieved examples match your installed version
GitHub	Repositories	Search code, inspect issues, and work with pull requests	Use a restricted token and review write permissions
Playwright	Browser testing	Navigate, snapshot, click, and capture pages in a real browser	Browser sessions can reach external sites and execute page code
Figma	Design handoff	Read structured layouts, components, and design tokens	Limit access to the files and teams needed for the project
Notion	Written specifications	Search pages and databases for requirements and decisions	Review which workspaces and pages the integration can read
Linear	Issue tracking	Read and update tickets from Cursor	Separate read-only investigation from issue-changing actions
Supabase	Backend development	Inspect projects, tables, and logs before writing SQL or application code	Keep production credentials and destructive operations tightly scoped
Sentry	Debugging	Query issues, events, and stack traces while fixing failures	Stack traces and event payloads may contain sensitive data
Firecrawl	Web research	Search, scrape, and crawl live pages	Check site permissions, robots policies, and the sensitivity of collected content
Stripe	Payment development	Search account data and work with payment-related API operations	Use test-mode credentials where possible and confirm every write

Which MCP server should you install first?

Need API or framework help? Install Context7.
Need repository context? Install GitHub.
Need end-to-end browser checks? Install Playwright.
Turning designs into code? Install Figma.
Working from product requirements? Install Notion.
Managing delivery work? Install Linear.
Writing database-backed features? Install Supabase.
Investigating production failures? Install Sentry.
Researching live websites? Install Firecrawl.
Building payment flows? Install Stripe.

For a general coding setup, a sensible first combination is Context7 plus GitHub. Add Playwright when browser behavior is part of your definition of done. Add systems that contain requirements, tickets, or production data only after reviewing their permissions.

Install an MCP server in Cursor

Option 1: Cursor Marketplace

Open Cursor’s MCP or Marketplace view.
Search for the server name.
Review the publisher, requested permissions, transport, and authentication method.
Install it at the project or global scope.
Restart or reload Cursor if the server does not appear immediately.
Run a harmless read operation and inspect the MCP logs.

Option 2: Project configuration

Create .cursor/mcp.json in the repository. The exact package name and arguments depend on the server’s official installation instructions; keep secrets in environment variables.

{
  "mcpServers": {
    "example-local-server": {
      "command": "npx",
      "args": ["-y", "YOUR_SERVER_PACKAGE"],
      "env": {
        "SERVICE_TOKEN": "${SERVICE_TOKEN}"
      }
    }
  }
}

Option 3: Global configuration

Use ~/.cursor/mcp.json when the server should be available across projects. Project configuration is easier to audit because it travels with the repository and can be reviewed by the team.

Remote server shape

{
  "mcpServers": {
    "example-remote-server": {
      "url": "https://service.example/mcp",
      "headers": {
        "Authorization": "Bearer ${SERVICE_TOKEN}"
      }
    }
  }
}

Use the provider’s documented URL, headers, or OAuth flow. Do not paste long-lived tokens into a committed file.

Transport, authentication, and permissions

Decision	What to check
Transport	Local stdio starts a process on your machine. Remote HTTP or SSE sends requests to a service. Confirm network, proxy, and firewall behavior.
Authentication	Determine whether the server uses OAuth, an API key, or an environment variable. Prefer short-lived or restricted credentials.
Read versus write	List tools that only inspect data separately from tools that create, update, delete, deploy, or charge.
Data sensitivity	Check whether prompts, source code, tickets, logs, design files, customer records, or payment data leave your machine.
Vendor trust	Review the source, release history, requested scopes, and network behavior before enabling a server.

Practical workflows

Current documentation with Context7

Ask Cursor to identify the package version in the project, retrieve documentation for that version, and then explain the change it plans to make. This reduces examples copied from an older API.

Repository work with GitHub

Use GitHub to locate related issues and pull requests, trace a change across files, and draft a patch. Require a review before any tool that writes to a branch, issue, or pull request.

Browser checks with Playwright

Ask Playwright to open the target route, wait for the application state, inspect the accessibility or DOM snapshot, perform the interaction, and capture evidence. Keep test credentials and target environments separate from production.

Requirements to implementation

Use Notion to retrieve the specification, Linear to identify the active issue, Figma to inspect component details, and GitHub to implement the change. Confirm that the retrieved sources are current before coding.

Debugging a production error

Use Sentry to find the issue and representative stack trace, Supabase to inspect relevant logs or schema, and GitHub to locate the introducing change. Redact sensitive event data before sharing it in a ticket or prompt.

Adding screenshot capability to Cursor

Playwright is the general browser-testing MCP: it can navigate, click, inspect, and take screenshots as part of an end-to-end check. If you only need reliable website images, a dedicated screenshot API removes browser setup and makes the capture request repeatable.

Or skip the browser setup

ScreenshotNeo is the first screenshot service to try when Cursor or an MCP agent needs clean website captures. Its MCP server provides take_screenshot, get_page_info, and capture_pdf tools for Claude, Cursor, and other MCP clients.

Before capture, it accepts cookie or consent banners and removes more than 60 known consent platforms, newsletter popups, and chat widgets. Bot checks, blank pages, timeouts, failed loads, and cache hits are not billed; response headers identify the page verdict and whether the request was billed.

The API supports PNG, JPEG, WebP, and PDF output, plus full-page capture, element selectors, dark mode, device presets, retina scale, waits, custom CSS and JavaScript, clicks, hidden selectors, request blocking, headers, cookies, user agents, authorization, timezone, geolocation, transparent backgrounds, resizing, caching, signed links, asynchronous jobs, bulk capture, and usage reporting. See the ScreenshotNeo documentation for parameter details.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

Free accounts include 1,000 screenshots each month with no card. Paid plans start at $5 for 3,000 screenshots. Create a free ScreenshotNeo account.

Security checklist

Install from a known source and inspect the server code or package metadata.
Use environment variables for API keys and OAuth tokens.
Grant the smallest repository, workspace, database, or account scope possible.
Prefer read-only credentials while evaluating a server.
Keep production and test credentials separate.
Review every write, deletion, deployment, and payment operation before it runs.
Check Cursor’s MCP logs when a tool behaves unexpectedly.
Audit generated code and external results; an MCP response is input to your review process, not automatic approval.

Performance, reliability, and cost

Latency: Local stdio avoids a network hop but still depends on process startup and the upstream API. Remote servers add network and authentication latency.
Reliability: A tool call can fail because Cursor, the MCP process, the network, or the vendor is unavailable. Keep a manual fallback for critical work.
Context size: Ask for focused searches and summaries. Pulling an entire repository, workspace, or database into context makes responses slower and less precise.
Cost: Check the provider’s API and plan limits. A free MCP client does not make the connected service free.
Writes: Batch safe reads, but confirm state-changing actions one at a time when the consequences are difficult to reverse.
ScreenshotNeo billing: Only clean shots are billed. Failed loads, bot checks, blank pages, timeouts, and cache hits cost nothing, and each response includes verdict and billing headers.

Troubleshooting

The server does not appear in Cursor

Check the file location and JSON syntax, confirm the command is installed, restart or reload Cursor, and inspect MCP logs. For remote servers, verify the URL and network access.

Authentication fails

Confirm that the environment variable is available to the process, the token has not expired, and its scopes include the requested operation. Avoid quoting mistakes in shell and configuration files.

Tools are visible but calls time out

Check the upstream service status, proxy or firewall rules, request size, and server logs. Narrow the query and retry with a small read-only operation.

Results contain stale documentation or data

Ask the server for the project’s exact version, branch, workspace, or environment. Verify the returned source and date before applying a change.

A write happened unexpectedly

Disable the server, revoke or rotate the credential, review its scopes, and inspect the tool definition and logs. Re-enable it with a read-only key until the workflow is understood.

ScreenshotNeo returns an unexpected page

Use a wait for a selector, delay, or network idle; check whether the target requires authentication; and inspect the X-Page-Verdict and X-Billed response headers. Block problematic resources or provide the required headers and cookies when appropriate.

FAQ

Are these servers ranked by install count?

No. The available sources list prominent official servers but do not publish comparable usage totals.

Should I install every server?

No. Start with the system tied to your immediate task, then add another when it removes a repeated manual step.

Is a remote MCP server less safe than a local one?

Neither transport is automatically safe. Compare code, permissions, authentication, network behavior, and data sensitivity.

Can Cursor use project and global MCP settings together?

Yes. Use project settings for repository-specific tools and global settings for tools you intentionally want across projects, while checking for duplicate names and conflicting configuration.

Which server handles screenshots?

Playwright can capture screenshots during browser tests. For clean, repeatable website images or PDFs, use ScreenshotNeo’s API or MCP server.