de en es ja ko ru zh

Netlify MCP Server

Name: Netlify MCP Server
Author: MCERQUA

by MCERQUA

Overview Schema Source Related Servers Discussions Admin

JavaScript

Remote

Netlify MCP サーバー

Netlifyサイトを管理するためのモデルコンテキストプロトコル（MCP）サーバー。このサーバーは、MCPを介してNetlify APIとのシームレスな統合を可能にし、MCP対応環境から直接サイトを作成、管理、デプロイできるようにします。

特徴

GitHub リポジトリから新しいサイトを作成する
既存のNetlifyサイトを一覧表示する
詳細なサイト情報を取得する
サイトを削除する

Related MCP server: Express MCP Server

インストール

このリポジトリをクローンします:

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

依存関係をインストールします:

npm install

プロジェクトをビルドします。

npm run build

構成

Netlifyアクセストークンの取得

https://app.netlify.com/signupで Netlify アカウントを作成します。
ユーザー設定 > アプリケーション > 個人アクセストークンに移動します
「新しいアクセストークン」をクリックします
名前を付けます（例：「MCP 統合」）
生成されたトークンをコピーする

MCPの設定

プロジェクトルートに.envファイルを作成します。

NETLIFY_ACCESS_TOKEN=your_token_here

MCP 設定構成にサーバーを追加します。

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

利用可能なツール

GitHubからサイトを作成する

GitHub リポジトリから新しい Netlify サイトを作成します。

interface CreateSiteFromGitHubArgs {
  name: string;          // Name for the new site
  repo: string;          // GitHub repository (format: owner/repo)
  branch: string;        // Branch to deploy from
  buildCommand: string;  // Build command to run
  publishDir: string;    // Directory containing the built files
}

リストサイト

アクセスできるすべての Netlify サイトを一覧表示します。

interface ListSitesArgs {
  filter?: 'all' | 'owner' | 'guest';  // Optional filter for sites
}

getSite

特定のサイトに関する詳細情報を取得します。

interface GetSiteArgs {
  siteId: string;  // ID of the site to retrieve
}

削除サイト

Netlify サイトを削除します。

interface DeleteSiteArgs {
  siteId: string;  // ID of the site to delete
}

ドキュメント

詳細については、以下を参照してください。

貢献

貢献を歓迎します！お気軽にプルリクエストを送信してください。

ライセンス

このプロジェクトは MIT ライセンスに基づいてライセンスされています - 詳細についてはLICENSEファイルを参照してください。

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.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

4 tool updatesv1.0.0Jan 2, 2026

ChangedcreateSiteFromGitHub7 fields changed

addedInput schema / properties / branch / default
```
Added value: +"main"
```

changedInput schema / properties / branch / description

Previous value: -"Branch to deploy from"New value: +"Branch to deploy from (default: main)"

changedInput schema / properties / buildCommand / description

Previous value: -"Build command to run"New value: +"Build command to run (e.g., npm run build)"

addedInput schema / properties / envVars

Added value: +{
+  "additionalProperties": {
+    "type": "string"
+  },
+  "description": "Environment variables for the build process",
+  "type": "object"
+}

changedInput schema / properties / name / description

Previous value: -"Name for the new site"New value: +"Name for the new site (will be used as subdomain)"

changedInput schema / properties / publishDir / description

Previous value: -"Directory containing the built files to publish"New value: +"Directory containing the built files to publish (e.g., dist, build)"

changedInput schema / required

Previous value: -[
-  "name",
-  "repo",
-  "branch",
-  "buildCommand",
-  "publishDir"
-]New value: +[
+  "name",
+  "repo",
+  "buildCommand",
+  "publishDir"
+]

ChangeddeleteSite1 field changed

changedInput schema / properties / siteId / description

Previous value: -"ID of the site to delete"New value: +"ID or name of the site to delete"

ChangedgetSite1 field changed

changedInput schema / properties / siteId / description

Previous value: -"ID of the site to retrieve"New value: +"ID or name of the site to retrieve"

ChangedlistSites3 fields changed

addedInput schema / properties / filter / default
```
Added value: +"all"
```

addedInput schema / properties / page

Added value: +{
+  "default": 1,
+  "description": "Page number for pagination",
+  "type": "number"
+}

addedInput schema / properties / perPage

Added value: +{
+  "default": 20,
+  "description": "Number of sites per page (max 100)",
+  "type": "number"
+}

4 tool updatesMay 18, 2025
- First observedcreateSiteFromGitHub
- First observeddeleteSite
- First observedgetSite
- First observedlistSites

Deploy Server

Shareable, User-Owned Context BackendPeople, applications, and agents read, write, and coordinate together in one context lake. Reach it over MCP, a CLI, a Python SDK, or REST.fulcradynamics.comAd

TDQS

B3.2/5.0

Scored 2026-04-18 10:55 across 4 tools

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

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Reddit Discussion

Related Servers

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
ChrysaiOAuth
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-serverOAuth
com.niftypm
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Project Management Communication File Systems
2
Hatchable AOAuth
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