Skip to content

MCP servers for NetBox: the options compared

There are two MCP servers for NetBox from NetBox Labs itself, plus four more from outside the company — and they differ far more than the shared name suggests. The open source one is read-only with four tools; the managed one is a NetBox Cloud service with nearly a hundred, and it is the only option that routes agent writes through a branch a human has to merge. This page lists what exists as of 15 August 2026, what each one covers, where your credentials sit, and what happens when an agent writes.

This page puts all six MCP options we could find for NetBox side by side across ten dimensions. We make one of them, which is why the sourcing rules below matter: no scores, no stars, no rankings — every cell states a fact and links to the evidence.

The real choice is not the tool count but the shape of access: a small NetBox-specific agent connector, NetBox Cloud’s integrated agentic change workflow, or one governance layer across NetBox and further systems. As of 15 August 2026 the field looks like this — six MCP options, plus seven adjacent projects that turn up under the same search terms but are not comparable options. Every claim in the table is a summary of sourced cells in the comparison matrix below.

OptionFits whenWritesKey limitVerification
nboxReads first; writes only behind an explicit plan/apply step, with caller identity (OIDC) on the write pathOpt-in and narrow: status, description, tags, IP/prefix/range reservationDeliberately small write surface; self-declared pre-1.0Docs review
NetBox Labs Platform MCP ServerOn NetBox Cloud, with governed agent writes reviewed in branchesYes, from the Starter plan; individually or in bulk, through isolated branches a human mergesNetBox Cloud only — no self-hosted or firewalled instances todayDocs review
NetBox MCP EnhancedWrites against a self-hosted NetBox, with named tools per object familyYes — 72 write tools, 69 named per object type plus three generic ones, straight to the live instanceOver HTTP unauthenticated unless MCP_AUTH_TOKEN is set, and then one token shared by all callersDocs review
NetBox MCP ServerExperimenting, or read-only access with the smallest possible surfaceNo — read-only by designNo writes, no GraphQL; the HTTP transport is unauthenticated unless MCP_AUTH_TOKEN is setDocs review
netbox-mcp-rwGeneric CRUD including bulk, as a local subprocess of one clientYes — nine generic tools including bulk, straight to the live instanceOne subprocess per client; unchanged since September 2025, validation and tests open on the roadmapDocs review
ToolMesh + netbox.dadlour projectSelf-hosted NetBox alongside other systems, behind one governance layerYes — every tool carries an access class (read/write/dangerous/admin) that policies can gateA standing service to operate; no /api/plugins/ (NetBox Branching), no GraphQL, no bulk writesHands-on tested

What separates them. Coverage runs from 4 tools to 608. Three options discover plugin object types at runtime: the two NetBox Labs servers and, since v1.1.0, NetBox MCP Enhanced. Only three of the six give callers their own identity — the rest work through a single NetBox token, and the HTTP transports of the OSS server and NetBox MCP Enhanced are unauthenticated unless you set MCP_AUTH_TOKEN, which both READMEs say plainly. On write safety the spread is widest: three options write straight to the live instance, nbox splits writes into plan and apply, and only the Platform server isolates them in a branch with a diff a human approves.

nbox

Communitylance0Last verified: 2026-08-15

A Rust binary that is a terminal UI, a CLI and an MCP server at once. The MCP side is read-first: eleven read tools plus every object as an nbox:// resource, with two opt-in write tools behind a plan/apply step. The only community option with OIDC and a per-user vault on its HTTP write path. Self-declared pre-1.0.

NetBox Labs Platform MCP Server

First-partyNetBox LabsLast verified: 2026-08-15

The managed first-party server, in Public Preview on NetBox Cloud since June 2026. Nearly 100 tools covering reads, writes, bulk operations, IPAM allocation, cable tracing, GraphQL, config rendering and scripts, plus other NetBox Labs products. It is the only option here that routes agent writes through isolated branches a human reviews and merges, and the only one with dynamic model discovery that picks up installed plugins. Nothing to install; NetBox Cloud only.

NetBox MCP Enhanced

CommunityskuldgerryLast verified: 2026-10-21

A write-enabled derivative of the NetBox Labs OSS server: its four read tools plus 72 write tools -- named create/update/delete tools for sites, tenants, tags, VLANs, IPAM, DCIM, circuits, virtualization, regions and locations, and three generic ones. Ships a Docker image, a Docker Compose path and HTTP transport for web clients, with an optional shared bearer token. Plugin object types are opt-in: discovered at startup and read-only unless a write rule allows a specific operation. Licensed Apache-2.0 since v1.1.0.

NetBox MCP Server

First-partyNetBox LabsLast verified: 2026-08-15

The open source first-party server and, by adoption, the reference implementation: 213 stars and 94 forks, last pushed the day before this survey. Deliberately small -- four read tools over 127 core object types, no writes, no GraphQL -- and the project states that keeping it small is the point, with forking under Apache 2.0 as a supported path. The only option here with a signed, provenance-carrying container image.

netbox-mcp-rw

Communityalexkiwi1Last verified: 2026-08-15

Nine generic tools -- get, get-by-id, create, update, delete, the three bulk variants and changelogs -- that work against any NetBox object type rather than one tool per type. The most-starred community option with writes. The README calls it production ready while the roadmap still lists input validation, tests and async support as open. Created and last pushed on the same day in September 2025.

ToolMesh + netbox.dadl

VendorDunkel Cloud GmbHLast verified: 2026-08-15

Not a NetBox-specific server but a self-hosted gateway reading a declarative YAML description of the NetBox REST API -- 608 tools, 98% of the API surface, the broadest coverage in this list. Governance (per-tool and per-user authorization, server-side credentials, output policies, audit) comes from the gateway rather than the connector. Two gaps follow from the static description: no dynamic plugin discovery, and no access to /api/plugins/ endpoints, which rules out driving NetBox Branching.

Our project — see the disclosure below

Rows are the ten dimensions; columns are the options. The table scrolls horizontally. Superscript numbers link to the source for that cell.

“Not documented” means the sources we checked do not state it — not that the feature is absent. If you maintain one of these projects and we got something wrong, open an issue and we will fix the data file.

Columns:
DimensionnboxNetBox Labs Platform MCP ServerNetBox MCP EnhancedNetBox MCP Servernetbox-mcp-rwToolMesh + netbox.dadlour project
Maintainer typeCommunity -- single maintainer1First party -- NetBox Labs, commercial2Community -- single maintainer3First party -- NetBox Labs, open source4Community -- single maintainer5Vendor -- Dunkel Cloud GmbH (publisher of this page)7
LicenseApache-2.0 or MIT (dual)1Proprietary (managed service)2Apache-2.03Apache-2.04Apache-2.05Apache-2.0 (gateway and DADL registry)7
Runtime & installRust static binary; cargo, Homebrew, GHCR image, signed release archives1None -- managed endpoint2Python 3.11 to 3.14; uv or pip, the published Docker image, or Docker Compose3Python 3; uv or pip, or the published Docker image4Python 3.13+; git clone plus uv or pip5Single Go binary; the DADL is one YAML file referenced from backends.yaml8
Last code activity12 Aug 20261Not applicable -- no public repository213 Oct 2026; latest release v1.1.1 (13 Oct 2026)914 Aug 2026; latest release v1.2.1 (17 Jun 2026)1014 Sep 2025 -- created and last pushed the same day5netbox.dadl last reviewed 15 Aug 20268
Public adoption signal7 stars, 1 fork1Not published27 stars, 2 forks3213 stars, 94 forks416 stars, 7 forks55 stars, 0 forks (gateway repository)7
Maturity (self-declared)"pre-1.0"1Public Preview -- fully functional, no SLA2No claim in the README; the package metadata classifies it as Beta11Versioned releases since v1.0.0 (Oct 2025)10"Production Ready"; the roadmap lists validation, tests and async as open5Gateway is pre-1.0; the NetBox DADL is live-verified7
Tools / actions11 read tools plus 2 opt-in write tools1"nearly 100 tools" -- vendor figure, not independently counted124 read tools plus 72 write tools: 69 named per object type and 3 generic34 tools -- get_objects, get_object_by_id, get_changelogs, search_objects139 generic tools covering CRUD, the three bulk variants and changelogs5608 tools -- 608 of ~620 REST endpoints (98%)6
Read / write / deleteRead-only by default; writes are opt-in and narrow (status, description, tags, IP/prefix/range reservation)1Read, write and delete, individually or in bulk; writes require a Starter plan or above2Read, write and delete3Read only -- by design, no write tools exist4Read, write and delete, including bulk5Read, write and delete; every tool carries an access class (248 read, 207 write, 114 dangerous, 39 admin)8
Core object coverageLookup-shaped: devices, IPs, prefixes, VLANs, sites, racks, rack groups, circuits, virtual circuits and more1Discovered dynamically at startup -- every object type the instance exposes2Core object types; 24 of them have named write tools, the generic tools reach the rest3127 core object types across dcim, ipam, circuits, virtualization, tenancy, vpn, wireless, extras, users and core14README lists DCIM, IPAM, circuits and virtualization; the generic tools accept any type name5DCIM, IPAM, virtualization, tenancy, circuits, wireless, VPN, extras, users and core, each declared endpoint by endpoint8
Plugin object typesNot documented1Yes -- discovered dynamically at startup, so the tool surface grows with the instance2Optional since v1.1.0 -- ENABLE_PLUGIN_DISCOVERY at startup, off by default; plugin types stay read-only unless PLUGIN_WRITE_RULES allows exact operations3Optional -- ENABLE_PLUGIN_DISCOVERY queries core/object-types at startup (NetBox 4.2+); off by default4No -- plugin support is listed on the roadmap as open5No -- /api/plugins/ endpoints are explicitly out of scope for a general DADL8
GraphQL, scripts, config rendering, cable tracingCable paths are rendered in detail views; GraphQL, scripts and config rendering are not documented1All four -- GraphQL from Starter, cable tracing, config rendering and script execution from Professional2Not documented3None -- GraphQL and dynamic model discovery are stated as deliberately out of scope4Not documented5Scripts (+run), config templates (+render), cable trace and paths actions, rack elevation; GraphQL is not covered8
Next-available allocation (IP, prefix, VLAN, ASN)Yes -- next-ip and next-prefix read-only, plus ip/prefix/ip-range reserve as writes1Yes -- available prefixes, IPs, VLANs and ASNs, from Professional2Not documented3Not applicable -- read only4Not documented5Yes -- available-prefixes, available-ips, available-vlans and available-asns are declared8
Method towards NetBoxNetBox API token from config.toml or an env var1NetBox v2 token (nbt_) as a Bearer header on the endpoint2NETBOX_TOKEN via environment or Docker Compose3NETBOX_TOKEN via CLI argument, environment variable or .env file4NETBOX_TOKEN via environment variable5Bearer token, injected server-side from the gateway's credential store at call time15
Where the secret livesconfig.toml (0600 on Unix, redacted in config show) or an env var; no OS keyring1In the client configuration -- the token is sent as a header on every connection2On the host running the server3On the machine running the server -- client config, environment or .env4On the client machine, in the LLM client configuration or the environment5Server-side in the gateway's credential store; not passed to the client or the model15
Who may call the serverstdio is a local subprocess; the HTTP transport supports OIDC with a per-user vault for writes1Anyone with a valid NetBox token; the agent acts with that token's RBAC permissions2Optional MCP_AUTH_TOKEN bearer on the HTTP transport since v1.1.0; unauthenticated when unset, which the README flags explicitly3Optional MCP_AUTH_TOKEN bearer on the HTTP transport; unauthenticated when unset, which the README flags explicitly4Not applicable -- local subprocess of one client5Authenticated gateway users with a per-user identity16
Least privilegeThrough the NetBox token; read-only by default and writes require an explicit flag plus confirmation1NetBox RBAC per token, plus tier-enforced tool registration and an optional per-connection read-only flag2Through the NetBox token's permissions; the README recommends read-only tokens for read use3Through the NetBox token; the README asks for a read-only token4Through the NetBox token's permissions5NetBox token permissions plus per-tool, per-user authorization in the gateway16
Deployment modeLocal subprocess (stdio) or a loopback HTTP service1SaaS -- runs as part of your NetBox Cloud infrastructure2Local subprocess or a self-hosted HTTP service (Docker image, Docker Compose or Python)3Local subprocess or a self-hosted HTTP service (container or Python)4Local subprocess on the client machine5Self-hosted gateway (binary or container)7
Data pathClient to nbox to NetBox; no third party1Client to NetBox Cloud; the server is part of the NetBox instance, so no separate vendor hop2Client to local or self-hosted server to NetBox; no third party3Client to local or self-hosted server to NetBox; no third party4Client to local server to NetBox; no third party5Client to your gateway to NetBox; no third party7
Works with a firewalled self-hosted NetBoxYes -- runs wherever you run it1No -- NetBox Cloud only; NetBox Enterprise support is stated as planned for later this year2Yes -- runs inside your network3Yes -- explicitly stated to work against private NetBox instances4Yes -- runs on the operator's machine5Yes -- the gateway runs inside your network7
NetBox versionsVersion-aware -- capability preflight via status, with features gated on NetBox 4.5+ and 4.6+1Not applicable -- the managed instance is the version2Not documented3Core types work broadly; plugin discovery requires NetBox 4.2+, with an endpoint fallback for NetBox < 4.44Not documented5Targets NetBox v4.x; individual endpoints are annotated with the version that introduced them (4.1, 4.2, 4.3, 4.5+)8
Edition / hosting dependencyNone -- any reachable NetBox1NetBox Cloud subscription; capabilities are mapped to Free, Starter, Professional and Premium tiers2None -- any reachable NetBox3None -- any reachable NetBox4None -- any reachable NetBox5None -- any reachable NetBox; the instance URL is set in backends.yaml8
Tool allow/denyCoarse -- writes are enabled or not, via --local-writes or --allow-writes plus an nbox:write caller scope1Yes -- mode=discrete|code|both and read_only per connection, plus tier-enforced tool registration2For plugin types only -- PLUGIN_WRITE_RULES enables exact create, update or delete per type; no switch documented for the core write tools3Not applicable -- four read tools, nothing to gate4Not documented5Yes -- per-tool, per-user policies over four access classes16
Read-only modeDefault -- writes require an explicit flag1?read_only=true per connection, or locked instance-wide on request to support2Not documented -- use a read-only NetBox token3Inherent -- no write tools exist4Not documented -- use a read-only NetBox token5Via authorization policy and/or a read-only NetBox token16
Audit trail in the connectorNot documented; writes accept an optional --message that lands in the NetBox changelog1Every call is attributed to the human whose token authorized the agent; NetBox's own changelog applies12Not documented -- NetBox's own changelog still applies3Not documented -- NetBox's own changelog still applies4Not documented; the README points at NetBox's built-in changelog5Structured log per call, attributed to user and caller, on a fail-closed pipeline7
DLP / redaction of responsesNot documented1Not documented2Not documented3Not documented4Not documented5Output Gate -- JS policies before and after execution, with redaction17
Distribution & pinningcrates.io, Homebrew tap, GHCR multi-arch image and release archives with SHA256SUMS1Vendor-operated; no artifact to pin2Docker Hub image skuldgerry/netbox-mcp with version tags, digest stated in the release notes; no signed image documented9Tagged releases plus multi-arch Docker Hub images signed with cosign (keyless, GitHub OIDC) and carrying SLSA build provenance4git clone; no published package or signed release5Tagged releases and container images; the NetBox description is a versioned YAML file in a public registry8
Dependency surfaceOne static Rust binary, no runtime; optional features can be compiled out1Opaque -- vendor-operated2Python plus fastmcp, httpx, pydantic and pydantic-settings, locked in uv.lock11Python plus fastmcp, httpx, pydantic and starlette13Python 3.13+ plus FastMCP5One static Go binary; adding NetBox introduces no further runtime dependency, only a YAML file7
Defence against prompt injectionNot documented1No classifier documented; exposure is bounded by RBAC, read-only mode, branching and a sandboxed Code Mode instead12Not documented3Not documented4Not documented5No classifier ships; response text can be screened in an Output Gate post-policy, but none does so by default17
Transportstdio, plus an optional loopback HTTP transport with OIDC1MCP over streamable HTTP2stdio (default) and Streamable HTTP, endpoint /mcp on port 80003stdio (default) and HTTP, endpoint /mcp on port 80004stdio -- the only transport documented5Streamable HTTP; stdio when the gateway runs locally as a single-user subprocess18
Remote / multi-user capableYes over HTTP -- OIDC callers with a per-user vault for writes1Yes -- each caller brings their own NetBox token and RBAC identity2Reachable over HTTP with one shared bearer; all callers share the server's single NetBox token3Reachable over HTTP with one shared bearer; all callers share the server's single NetBox token4No -- one subprocess per client5Yes -- multi-user with per-user authorization16
Catalog cost in context13 tools -- small; the README claims a ~9 ms cold start as one static binary1Nearly 100 tools in discrete mode; Code Mode replaces them with three tools, for which the vendor claims 85% less context overhead276 tools loaded up front: 4 read, 72 write34 tools -- negligible, though the get_objects description embeds the full list of 127 object types139 tools -- negligible5608 tools, but Code Mode replaces the catalog with two meta-tools, keeping the loaded context near-flat19
DiscoveryStatic tool list1Dynamic model discovery at startup; Code Mode adds a schema-exploration tool and a discovery-refresh tool2Static tool list3Static tool list; optional plugin type discovery extends the type registry, not the tool list4Static tool list5Progressive, ranked tool discovery19
Response size control--fields, -o plain|json|csv, and a ~30 s per-profile read cache1Not documented at field level; Code Mode aggregates in the sandbox so raw responses need not enter context2fields parameter on the two main read tools, inherited from upstream3fields and brief parameters, limit default 5 and max 100, plus filter validation that rejects __in and multi-hop lookups13Not documented5Offset pagination with max 20 pages and a 500-item response cap declared in the DADL, plus ?brief and ?fields hints per tool8
Branching / review before mergeNo -- writes land directly on the live instance1Yes -- agents work in isolated branches, propose diffs and merge only through human review; change request workflows and NetBox Validation pre-change analysis are wired into the same connection (Professional+)12No -- writes land directly on the live instance3Not applicable -- read only4No -- writes land directly on the live instance5No -- NetBox Branching is a plugin served under /api/plugins/branching/, and those endpoints are explicitly out of scope for netbox.dadl, so branches cannot be driven through the gateway today20
Dry-run / confirmation before a writeYes -- --dry-run, or --allow-writes plus an explicit --confirm; the MCP side splits this into plan_write and apply_write1Branch diffs act as the review step; the docs additionally recommend enabling tool approval prompts in the MCP client2Not documented3Not applicable -- read only4Not documented; the README warns to test in a development environment first and to use bulk operations carefully5Human-in-the-loop is available as a gateway policy; 114 tools are classed dangerous and 39 admin, which a policy can gate on8
Bulk operationsNarrow -- ip reserve --count N posts one list body atomically; nothing broader1Yes -- create, modify and delete objects individually or in bulk (Starter+)2Not documented as a separate capability3Not applicable -- read only4Yes -- dedicated bulk create, update and delete tools5No -- bulk PUT/PATCH/DELETE on collections is explicitly not covered; per-object operations in Code Mode are the stated alternative8

When a dedicated NetBox server is the better choice

Section titled “When a dedicated NetBox server is the better choice”

A gateway that reads a static description of the NetBox REST API reaches exactly what that description declares — no less, and structurally no more. Four things sit outside ours, and for those a purpose-built server wins:

  • /api/plugins/ endpoints — which is where NetBox Branching actually lives. The branching REST API sits under /api/plugins/branching/, and netbox.dadl explicitly excludes plugin endpoints, so branch-based review of agent writes cannot be driven through the gateway today. The Platform MCP Server has branching wired in natively.
  • Dynamic model discovery. A static description cannot notice at startup which plugins an instance has installed. The Platform MCP Server discovers every object type the instance exposes; the OSS server can optionally discover plugin object types on NetBox 4.2+, and NetBox MCP Enhanced has offered the same opt-in discovery since v1.1.0.
  • GraphQL. netbox.dadl covers the REST API only. The Platform MCP Server offers GraphQL queries from the Starter tier.
  • Bulk collection operations. Bulk PUT/PATCH/DELETE on collections is explicitly not covered in netbox.dadl — per-object calls in Code Mode are the stated alternative. The Platform MCP Server and netbox-mcp-rw both ship dedicated bulk tools.

A gateway reading a static description reaches none of these. If your use case depends on one of them, pick accordingly.

A gateway earns its keep when NetBox is not the only system in the picture:

  • Questions that span systems. “Which hosts are critical in Checkmk, and who owns them in NetBox?” is one agent turn against one endpoint, instead of two connectors that cannot see each other. The public DADL registry lists 30 APIs and over 4,000 tools as of August 2026, so the second system is often already described.
  • One place for credentials. The NetBox token lives server-side and is injected at call time, rather than sitting in every operator’s client configuration.
  • One authorization model and one audit trail across every connected system, instead of per-connector conventions.
  • Context economy at scale. 608 NetBox tools is a lot of schema for a model to carry; a catalog that stays flat matters more the more systems you connect. This one is not ours alone — the Platform MCP Server’s Code Mode solves the same problem for NetBox Cloud.

The honest trade-off: a gateway is a standing service you have to run, monitor and keep available. The dedicated servers’ leanest shape is a subprocess your LLM client launches — nothing to operate at all. Run one of them centrally over HTTP instead and you are operating a component too; the count evens out, and the difference shifts to what the matrix above shows: a service fronting one system on a shared NetBox token versus a multi-user gateway fronting several. Either way, a gateway only pays for itself once more than one system is behind it. If NetBox is the only thing you will ever connect, and reads are all you need, the first-party open source server is the leaner answer. It exists, it is four tools, and it cannot change a single NetBox object.

The machine-readable coverage report for our option — every tool, its access class, and which parts of the NetBox REST API are and are not covered — is at dadl.ai/d/netbox. It records 608 tools over 608 of roughly 620 REST endpoints (98%), each tool carrying one of four access classes (248 read, 207 write, 114 dangerous, 39 admin), with the uncovered areas named explicitly: plugin endpoints, GraphQL and bulk collection writes.

Is there an official MCP server for NetBox?

Yes — two, and they barely overlap. The open source NetBox MCP Server (Apache-2.0) is deliberately small: four read tools over 127 core object types, no writes, no GraphQL, and by adoption it is the reference implementation. The Platform MCP Server is a managed NetBox Cloud service in Public Preview since June 2026: nearly 100 tools (the vendor's figure) covering reads, writes, bulk operations, GraphQL, config rendering and scripts, with agent writes routed through isolated branches. Only the first has a public repository — a GitHub search surfaces it, not the managed service.

Can an AI agent write to NetBox through MCP, or only read?

It depends on the option. The NetBox Labs OSS server is read-only by design — no write tools exist. nbox is read-only by default, with two opt-in write tools that are deliberately narrow and split into plan and apply. NetBox MCP Enhanced adds 72 write tools, 69 named per object type plus three generic ones, to the OSS server's four read tools. netbox-mcp-rw exposes generic create, update and delete including bulk variants. The Platform MCP Server writes from the Starter plan upward, individually or in bulk. ToolMesh + netbox.dadl declares write and delete tools across the API, each classed read, write, dangerous or admin so a policy can gate them.

Which option can use NetBox Branching, so agent changes are reviewed before they merge?

Only the Platform MCP Server. It works in isolated branches, proposes diffs, and merges only through human review, with change request workflows and NetBox Validation pre-change analysis on the same connection. NetBox Branching is a plugin whose REST API lives under /api/plugins/branching/, and netbox.dadl explicitly excludes plugin endpoints — so branches cannot be driven through our gateway today. The remaining write-capable options write directly to the live instance; nbox's plan/apply step is a confirmation gate, not an isolated branch.

Where do my NetBox credentials end up?

nbox reads the API token from a config.toml (0600 on Unix, redacted in config show) or an environment variable. NetBox MCP Enhanced and the NetBox Labs OSS server take it from the environment of the machine running the server; netbox-mcp-rw reads it from the LLM client's configuration or environment on the client machine. The Platform MCP Server takes a NetBox v2 token as a header on every connection, so the secret sits in each caller's client configuration and the agent acts under that token's RBAC permissions. ToolMesh keeps the token server-side in the gateway's credential store and injects it at call time, so it never appears in a client configuration.

Do these work with a self-hosted NetBox behind a firewall?

Five of the six do, because you run them yourself inside your network. The exception is the Platform MCP Server: it is part of NetBox Cloud and works only there, with NetBox Enterprise support stated as planned for later this year.

Do plugin object types work over MCP?

Through three of them. The Platform MCP Server discovers every object type the instance exposes at startup, plugins included. The OSS server has optional plugin discovery (ENABLE_PLUGIN_DISCOVERY, NetBox 4.2+, off by default), which extends its type registry. NetBox MCP Enhanced added the same opt-in discovery in v1.1.0; discovered plugin types stay read-only unless PLUGIN_WRITE_RULES allows specific operations per type. netbox-mcp-rw lists plugin support as an open roadmap item, and netbox.dadl excludes /api/plugins/ endpoints as out of scope for a general description.


Reference from here on — the adjacent projects, the methodology and disclosure, the changelog and the sources. Nothing below is needed for the decision above; it is where the evidence lives.

Adjacent projects that are not listed as options

Section titled “Adjacent projects that are not listed as options”
Show the seven projects

Found under the same search terms, but not comparable options under the inclusion criterion — each with the reason:

netboxlabs/skills
An Apache-2.0 library of Agent Skills from NetBox Labs that teach an agent NetBox conventions, API patterns and branching workflows. Not an MCP server -- it is knowledge, not access -- but it is installed alongside one, and it works with any of the options here.
NetBox Copilot
An AI assistant from NetBox Labs embedded in the NetBox UI, in public preview. It is used inside NetBox, not called by an external agent, so it is not an MCP server.
simonpainter/netbox-mcp
A small FastMCP server over streaming HTTP with four tools covering sites and site groups, written up in a blog series and therefore easy to find. Its README states it is provided as-is and no license is declared, and the tool surface is too narrow to compare across the ten dimensions.
thomaschristory/netbox-mcp-server-extended
A write-enabled fork of the NetBox Labs OSS server that tracks upstream automatically, Apache-2.0 and actively pushed. Listed as adjacent rather than as an option because it is a fork whose stated purpose is to follow another listed option; worth promoting to a full entry if it develops an independent scope.
imunhatep/netbox-mcp-go
A NetBox MCP server in Go under AGPL-3.0, created in August 2026. Too new to assess -- one week of history at the time of this survey. Re-check at the next registry diff.
automateyournetwork/NetBox_MCP
An Apache-2.0 demonstration server from a network automation training channel, created in January 2025. The repository carries no README documenting a tool surface, so nothing beyond dimension 1 could be filled.
pamosima/network-mcp-docker-suite
A Docker suite bundling MCP servers for seven systems, NetBox among them. It is a multi-system bundle rather than a dedicated NetBox server, which is a different category from every option on this page.
Show methodology and disclosure

Disclosure. This page is published by Dunkel Cloud GmbH, which makes ToolMesh — one of the six options listed. We have an obvious interest in how it looks. The countermeasures are structural: options are ordered alphabetically by display name, our own entry included; every cell carries a source link; no cell contains a score or a ranking; and the two “when to choose” sections above name the cases where our option is the wrong tool.

Inclusion criterion. A GitHub search for “netbox mcp”, “netbox mcp server” and “netbox model context protocol” on 15 August 2026 returned 46 repositories; the managed Platform MCP Server has no public repository and entered through the accompanying vendor research. An option is listed when all three points hold: a publicly reachable source or product page; presented as a usable server rather than a demo, course artifact or personal fork without independent substance; and documentation sufficient to fill at least the profile dimension. Six options met all three — five public repositories plus the managed Platform MCP Server. Seven projects are documented as adjacent, and the rest are forks, course artifacts and one-day experiments without a README or license.

How the facts were gathered. Each option’s own repository, README, documentation and — where cited — source code, read on 15 August 2026. Repository metadata — license, last commit, stars and forks — comes from the GitHub API on the same date. NetBox MCP Enhanced was read again on 21 October 2026, after its maintainer reported a change; its row and its metadata reflect that date. Where a project does not state something, the cell says “not documented” rather than guessing. For hosted products that means the platform documentation, not only a product page: the Platform MCP Server’s capabilities are documented across the NetBox Cloud documentation and the vendor’s launch post, and both are cited. Registry aggregators were used only to find candidates, never as evidence.

Depth of verification. The five options we do not maintain are documentation and source-code review, not test results — read, not run. The verification column in the decision table states this per option, and vendor figures we cannot count ourselves are quoted as such. Our own entry is the exception: the netbox.dadl behind it is live-verified, and its row was last reviewed on 15 August 2026. The maintainers of all listed projects were notified when this page went live; if a documentation review got something wrong, their corrections land in the data file.

Corrections and additions. The matrix lives as one YAML file in this site’s repository; the site repository itself is private, so corrections travel as issues on the public ToolMesh repository. Correcting a fact, or adding an option we missed, takes one issue. Maintainers: if we have misrepresented your project, that is a bug and we will fix it.

Show changelog
NetBox MCP Enhanced updated after its maintainer reported a change: the project is licensed Apache-2.0 since v1.1.0 (29 August 2026). Its row was re-read against the repository on 21 October 2026, which also brought in what v1.1.0 and v1.1.1 added: 72 write tools, an optional shared bearer token on the HTTP transport, opt-in plugin discovery and a published Docker image.
First publication. Six MCP options compared across the ten dimensions, plus seven adjacent projects found under the same search terms that are not comparable options. Facts taken from each project's own repository and documentation; our own entry is backed by the live-verified netbox.dadl.
Show all sources