What can you do with this server?

The Netlify MCP Server allows you to manage Netlify sites through a Model Context Protocol (MCP) interface. You can: * Create new sites from GitHub repositories by specifying name, repository, branch, build command, and publish directory * List existing Netlify sites with optional filtering by access type * Retrieve detailed information about specific sites using their IDs * Delete Netlify sites from your account

Which integrations are available for this server?

Allows creating Netlify sites from GitHub repositories by specifying repository details, branch to deploy from, and build configuration. Enables site management on Netlify's platform, including creating new sites from GitHub repositories, listing existing sites, retrieving detailed site information, and deleting sites.

How do I use Netlify MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Netlify MCP Server create a new site from my GitHub repo glama-ai/demo-app with build command 'npm run build' and publish directory 'dist'" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

de en es ja ko ru zh

Netlify MCP Server

by MCERQUA

Overview Schema Related Servers Score Discussions

JavaScript

Remote

Netlify MCP Server

MCP Server License: MIT

A Model Context Protocol (MCP) server for managing Netlify sites. This server enables seamless integration with Netlify's API through MCP, allowing you to create, manage, and deploy sites directly from your MCP-enabled environment.

Features

🚀 Create new sites from GitHub repositories
📋 List existing Netlify sites with pagination
🔍 Get detailed site information
🗑️ Delete sites
🔐 Secure authentication with Netlify API
⚡ Built with TypeScript for type safety
🐳 Docker support for easy deployment

Related MCP server: Express MCP Server

Requirements

Node.js 18 or higher
A Netlify account with API access
A GitHub repository for deploying sites

Installation

From Source

Clone this repository:

git clone https://github.com/MCERQUA/netlify-mcp.git
cd netlify-mcp

Install dependencies:

npm install

Build the project:

npm run build

Using Docker

docker build -t netlify-mcp .
docker run -e NETLIFY_ACCESS_TOKEN=your_token_here netlify-mcp

Configuration

Getting Your Netlify Access Token

Create a Netlify account at https://app.netlify.com/signup
Go to User Settings > Applications > Personal access tokens
Click "New access token"
Give it a name (e.g., "MCP Integration")
Copy the generated token

Setting Up MCP

Create a .env file in the project root:

NETLIFY_ACCESS_TOKEN=your_token_here

Add the server to your MCP settings configuration:

{
  "mcpServers": {
    "netlify": {
      "command": "node",
      "args": ["path/to/netlify-mcp/build/index.js"],
      "env": {
        "NETLIFY_ACCESS_TOKEN": "your_token_here"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Available Tools

createSiteFromGitHub

Create a new Netlify site from a GitHub repository.

interface CreateSiteFromGitHubArgs {
  name: string;          // Name for the new site (subdomain)
  repo: string;          // GitHub repository (format: owner/repo)
  branch?: string;       // Branch to deploy from (default: main)
  buildCommand: string;  // Build command to run
  publishDir: string;    // Directory containing the built files
  envVars?: Record<string, string>; // Environment variables
}

listSites

List all Netlify sites you have access to.

interface ListSitesArgs {
  filter?: 'all' | 'owner' | 'guest';  // Filter for sites
  page?: number;         // Page number for pagination
  perPage?: number;      // Items per page (max 100)
}

getSite

Get detailed information about a specific site.

interface GetSiteArgs {
  siteId: string;  // ID or name of the site
}

deleteSite

Delete a Netlify site.

interface DeleteSiteArgs {
  siteId: string;  // ID or name of the site
}

Documentation

For more detailed information, see:

Development

# Run in development mode with auto-rebuild
npm run dev

# Clean build artifacts
npm run clean

# Build the project
npm run build

Troubleshooting

Common Issues

"NETLIFY_ACCESS_TOKEN environment variable is required"
- Make sure you've set the token in your environment or .env file
"Failed to create site: 401 Unauthorized"
- Your access token might be invalid or expired
- Generate a new token from Netlify settings
"Invalid repo format"
- Ensure the repository is in format owner/repo
- Example: facebook/react, not https://github.com/facebook/react

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add some amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgments

Model Context Protocol for the MCP framework
Netlify for their excellent deployment platform

Available Tools

4 tools

createSiteFromGitHubC

Create a new Netlify site from a GitHub repository

ParametersJSON Schema

Name	Required	Description	Default
`name`	Yes	Name for the new site (will be used as subdomain)
`repo`	Yes	GitHub repository in format owner/repo
`branch`	No	Branch to deploy from (default: main)	main
`buildCommand`	Yes	Build command to run (e.g., npm run build)
`publishDir`	Yes	Directory containing the built files to publish (e.g., dist, build)
`envVars`	No	Environment variables for the build process

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool creates a site but doesn't mention critical behaviors like whether this requires specific permissions, if it's idempotent, what happens on failure, or if there are rate limits. This leaves significant gaps for an agent to understand the tool's operational characteristics.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence that directly states the tool's purpose without any unnecessary words. It's perfectly front-loaded and wastes no space, making it highly efficient for an agent to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a creation tool with 6 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what the tool returns upon success or failure, doesn't mention authentication requirements, and provides no context about the Netlify platform or GitHub integration. The agent would need to guess about many operational aspects.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, so all parameters are documented in the schema. The description doesn't add any additional parameter semantics beyond what's already in the schema, such as explaining relationships between parameters or providing examples. This meets the baseline expectation when schema coverage is complete.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Create') and resource ('new Netlify site from a GitHub repository'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'deleteSite' or 'getSite' beyond the obvious action difference, which is why it doesn't reach a perfect score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'listSites' or 'getSite', nor does it mention prerequisites such as GitHub authentication or Netlify account setup. It simply states what the tool does without contextual usage information.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

deleteSiteC

Delete a site

ParametersJSON Schema

Name	Required	Description	Default
`siteId`	Yes	ID or name of the site to delete

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Delete a site' implies a destructive, irreversible mutation, but it doesn't specify permissions required, whether deletion is permanent, what happens to associated resources, or error conditions. This is a significant gap for a destructive operation with zero annotation coverage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description 'Delete a site' is extremely concise—a single three-word phrase that front-loads the core action. There is zero wasted language, making it efficient and immediately clear, though this conciseness comes at the cost of completeness in other dimensions.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given this is a destructive mutation tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what 'delete' entails behaviorally, what the response might contain, or error handling. For a tool that permanently removes resources, more context is needed to guide safe and effective use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with the 'siteId' parameter fully documented as 'ID or name of the site to delete'. The description adds no additional parameter information beyond what the schema provides, so it meets the baseline of 3 where the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Delete a site' clearly states the verb (delete) and resource (site), making the tool's function immediately understandable. It doesn't explicitly differentiate from sibling tools like 'getSite' or 'listSites', but the action 'delete' inherently distinguishes it from those read-only operations.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing site), consequences of deletion, or when to choose other tools like 'createSiteFromGitHub' for creation instead. This leaves the agent without context for appropriate tool selection.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

getSiteC

Get details of a specific site

ParametersJSON Schema

Name	Required	Description	Default
`siteId`	Yes	ID or name of the site to retrieve

TDQS

C2.9/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Get details' which implies a read-only operation, but doesn't clarify aspects like whether it requires authentication, rate limits, error handling (e.g., for invalid site IDs), or what 'details' includes (e.g., fields returned). For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence with zero wasted words. It's front-loaded with the core purpose ('Get details of a specific site'), making it immediately understandable. Every word earns its place, and there's no unnecessary elaboration.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (1 parameter, no output schema, no annotations), the description is incomplete. It doesn't explain what 'details' are returned, which is crucial since there's no output schema. For a read operation with no annotations, it should at least hint at the response structure or key fields to make it fully usable by an agent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with the 'siteId' parameter clearly documented as 'ID or name of the site to retrieve'. The description doesn't add any meaning beyond this, as it doesn't elaborate on parameter usage or constraints. With high schema coverage, the baseline score of 3 is appropriate since the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Get details') and resource ('specific site'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'listSites' (which retrieves multiple sites vs. a single site), but the specificity of 'specific site' implies a single-item retrieval. This is clear but lacks explicit sibling differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to use 'getSite' vs. 'listSites' (e.g., for a single known site vs. browsing all sites) or prerequisites like needing a site ID. There's no explicit or implied context for usage beyond the basic purpose.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

listSitesB

List Netlify sites

ParametersJSON Schema

Name	Required	Description	Default
`filter`	No	Filter sites by access type	all
`page`	No	Page number for pagination
`perPage`	No	Number of sites per page (max 100)

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('List') but doesn't mention whether this is a read-only operation, if it requires authentication, what the output format looks like, or any rate limits. For a listing tool with zero annotation coverage, this leaves significant behavioral gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized for a simple listing operation and front-loads the essential information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a listing tool with three well-documented parameters but no annotations or output schema, the description is minimally complete. It identifies the resource but doesn't address behavioral aspects like pagination behavior, authentication needs, or output format, which could help the agent understand what to expect.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, thoroughly documenting all three parameters with their purposes, enums, defaults, and constraints. The description adds no additional parameter information beyond what the schema already provides, which is adequate but not additive.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('List') and resource ('Netlify sites'), making the purpose immediately understandable. However, it doesn't distinguish this tool from its siblings like 'getSite', which might retrieve a specific site rather than listing multiple sites.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'getSite' or 'createSiteFromGitHub'. There's no mention of prerequisites, typical use cases, or comparisons to sibling tools, leaving the agent without contextual usage cues.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.2/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose: createSiteFromGitHub creates sites from GitHub, deleteSite removes sites, getSite retrieves details, and listSites lists all sites. There is no overlap in functionality, making tool selection unambiguous.

Naming Consistency4/5

Three tools follow a consistent verb_noun pattern (deleteSite, getSite, listSites), but createSiteFromGitHub deviates slightly by including 'FromGitHub' for specificity. This minor inconsistency does not hinder readability, as the naming remains intuitive and mostly uniform.

Tool Count3/5

With only 4 tools, the server feels thin for managing Netlify sites, as it lacks operations like updating sites, managing deployments, or handling environment variables. While the core CRUD operations are covered, the scope is limited and may require workarounds for common workflows.

Completeness3/5

The tools cover basic CRUD operations (create, read, delete, list) for sites, but there are notable gaps such as updating site settings, managing deployments, or handling other Netlify resources like functions or forms. This incomplete surface could lead to agent failures for advanced tasks.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Reddit Discussion

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

neverinfamous-memory-journal-mcp
ai.smithery
A MCP server built for developers enabling Git based project management with project and personal…
Version Control Developer Tools Project Management
320
Chrysai
com.chrysai.www
Hosted MCP server for AI-driven data ops. Create apps, manage schemas, and CRUD structured data.
Data Platforms Developer Tools App Automation
2
mcp-server
com.niftypm
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Project Management Communication File Systems
2
Hatchable A
com.hatchable
Build, deploy, and host full-stack web apps from any MCP client. DB, auth, storage, cron included.
Cloud Platforms App Automation
2

Related MCP Servers

MCP Express Server for Netlify
Agent Orchestration Code Execution Developer Tools
lutfi-haslab
F
license
Not graded
quality
D
maintenance
A serverless implementation of the Model Context Protocol (MCP) that runs on Netlify Functions, allowing developers to build and deploy MCP-compatible services with minimal configuration.
Updated a year ago (2025-05-05 04:43 UTC)
Express MCP Server
Agent Orchestration Cloud Platforms
depeshmandalia
F
license
Not graded
quality
D
maintenance
A basic example of a serverless Model Context Protocol (MCP) implementation using Netlify Functions, allowing developers to run MCP services without managing traditional server infrastructure.
Updated a year ago (2025-05-08 00:53 UTC)
MCP Express on Netlify
khawjaahmad
-
license
Not graded
quality
Not graded
maintenance
A basic example of deploying a serverless Model Context Protocol (MCP) server using Netlify Functions, allowing developers to quickly create and deploy MCP-compatible AI agent backends.
Updated a year ago (2025-06-22 04:57 UTC)
Netlify Serverless MCP
Cloud Platforms Developer Tools CI/CD & DevOps
renovate-bot
F
license
Not graded
quality
D
maintenance
Demonstrates how to deploy and run Model Context Protocol (MCP) servers using Netlify's serverless functions. Provides a basic example of serverless MCP implementation with customizable URLs and automated deployment pipeline.
Updated a year ago (2025-09-26 03:43 UTC)

Appeared in Searches

Information about Gandhi or Gandi domain registrar

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/MCERQUA/netlify-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server