Tailscale MCP Server

io.github.YawLabs由 GitHub 账号 YawLabs 发布v0.23.4更新于 Nov 17, 2026

Tailscale MCP server for managing your tailnet from AI assistants

概览

AI 生成的概览

让助手查看并管理 Tailscale tailnet:设备、ACL 策略、DNS、密钥、用户与审计日志。

可以做什么
  • 检查连接状态,列出或查看设备、路由、标签与姿态属性
  • 授权、取消授权、重命名、使密钥过期或删除设备,支持批量授权
  • 读取、校验、预览并对比 ACL 策略,再以 ETag 保护方式更新
  • 读取并替换 DNS 名称服务器、搜索域、分离 DNS 与 MagicDNS 偏好
  • 列出、创建、更新和删除认证密钥、OAuth 客户端与联合身份
  • 读取审计日志与网络流日志,可选启用 ping、netcheck 等本地 CLI 诊断
适用场景
适合让助手回答跨接口的 tailnet 问题,或交互式起草并应用管理变更,例如找出长期未上线设备、在改 ACL 前确认谁会失去访问权、轮换过期认证密钥。若只是 CI 中一次固定 API 调用,直接用 curl 更简单。
运行要求
通过 npx 本地运行(需 Node.js)。需要 TAILSCALE_API_KEY 中的 API 密钥,或 TAILSCALE_OAUTH_CLIENT_ID 与 TAILSCALE_OAUTH_CLIENT_SECRET 的 OAuth 凭据,且作用域需覆盖所加载的工具组。可选变量可裁剪工具面(TAILSCALE_PROFILE、TAILSCALE_TOOLS、TAILSCALE_READONLY)或启用本地 CLI 工具(TAILSCALE_LOCAL_CLI、TAILSCALE_BINARY)。
安装前请注意
凭据拥有 tailnet 管理权限;README 提醒客户端 JSON 配置在多数系统上可被任意读取,建议把密钥放在 shell 配置中。许多工具会修改或删除状态:ACL 更新可能让设备全部失去访问,设备与密钥删除不可恢复,整体替换类接口会清空未传入的字段。新建密钥只返回一次,之后无法再取回。TAILSCALE_REQUIRE_APPROVAL 可加确认提示,但默认关闭。

安装

在 SourceWeft 中

  1. 打开 控制台中的 Tailscale MCP Server,将其添加到工作区。
  2. 为需要使用其工具的对话启用该服务。

Desktop only,通过 STDIO。 STDIO 服务会启动本地进程,因此需要 SourceWeft 桌面宿主。

其他 MCP 客户端

参照 仓库 中的启动说明。

README

@yawlabs/tailscale-mcp

[Add to Yaw MCP]

One click adds this to your local Yaw MCP config so it's available in every Yaw Terminal session. Or install manually below.

[npm version] [License: MIT] [GitHub stars] [Release]

Ask your agent questions about your tailnet and have it act on the answers. 97 admin-API tools + 6 optional local-CLI diagnostics + 1 always-on catalog tool + 4 resources spanning the Tailscale v2 API — devices, ACLs, DNS, keys and trust credentials, users, invites, webhooks, log streaming, posture, services, and organization tailnets. Backed by 1900+ unit tests and an opt-in live-tailnet integration suite.

Built and maintained by Yaw Labs.

What's the point if the API already exists?

You could curl the Tailscale API. The point isn't replacing curl — it's letting an agent compose multi-endpoint workflows in one turn without writing a script:

  • "Which devices haven't checked in for 30 days and have key expiry disabled?" — lists devices, filters by lastSeen (online devices carry none), filters by keyExpiryDisabled, returns a table. Three endpoints, one question.
  • "Someone broke DNS at 2am — who changed what in the last 24 hours?" — pulls the audit log, filters by DNS-related actors and endpoints, reads each change's before/after, summarizes in English.
  • "Draft an ACL change that lets tag:mobile reach tag:dashboard but not tag:db, preserving my comments" — reads the current HuJSON, proposes a minimal diff, validates it against the API, returns the diff for you to apply.
  • "Rotate every auth key older than 90 days and print the new ones" — iterates, creates new keys with matching tags, revokes the old ones.
  • "Create an OAuth client for our CI pipeline scoped to devices:core:read and dns:read" — creates a trust credential via tailscale_create_key with keyType=client, returns the credentials once (save them immediately).

A curl can do each step. The agent composes them. That's where the lift is, and that's what the tool surface is designed for — every read endpoint is first-class so the agent can synthesize, and every write endpoint is tagged destructiveHint or idempotentHint so your MCP client can gate mutations the way you configured it.

If all you need is one endpoint in a CI job, use curl — we even have a CLI subcommand for the common ACL-from-git case. The MCP is for the interactive, exploratory, "I don't know what I need yet" work.

Why MCP vs. a skill or the tailscale CLI?

Reasonable question. Both have their place. Where this MCP is better:

  • Broad admin API coverage. The tailscale CLI is scoped to the node it runs on. Admin concerns — ACLs, users, invites, webhooks, log streaming, posture integrations, auth keys, OAuth clients, and federated identities — live in the v2 HTTP API. You'd be shelling out to curl anyway.
  • Typed tool surface, not string parsing. Every tool has a Zod-validated input schema and a structured response. No brittle tailscale status --json | jq pipelines that break when the schema evolves.
  • Cross-client, and updates arrive as a version bump. An MCP server works in Claude Code, Claude Desktop, Cursor, Windsurf, VS Code, and anything else that speaks MCP; a skill written to the Agent Skills standard travels between agents too, but it is prose you maintain. Version bumps ship through npx — nobody rewrites a skill's instructions when Tailscale adds an endpoint.
  • Safe-by-default writes. Every tool declares readOnlyHint / destructiveHint / idempotentHint so clients can skip confirmation on reads and require it on mutations. A skill that shells out to the CLI can't express that.
  • Real tests. 1900+ unit tests covering every tool's input validation, API shape, and error handling. Plus an opt-in live-tailnet integration suite (RUN_INTEGRATION_TESTS=1 + a tailnet API key) for shape-drift detection. Most skills are short markdown prompts without their own test layer — if the vendor changes output format, nothing catches it for you.

If you already have a skill that covers your 10% of Tailscale workflows, great — keep it. The MCP is for the other 90%.

What about Tailscale's own MCP endpoints and skill? As of 2026-09-19 they solve different problems, and nothing here duplicates them. Tailscale's official MCP tools are two alpha built-in connectors inside Aperture: Tailnet, whose Tailnet_provision_node returns a single-use auth key so an agent can join one new node after a person approves it, and Tailscale SSH, whose TailnetSSH_list_machines and TailnetSSH_run_command discover SSH-enabled machines and run one command on one of them. They require Aperture. tailscale/tailscale-skill is an alpha, knowledge-only skill — reference material that teaches an agent to curl the v2 API, with no server of its own. Neither exposes the admin API as typed tools, so the overlap with this server is close to nil. Nor can Aperture front this one today: this server speaks stdio, and Aperture proxies only URL-addressable Streamable-HTTP or SSE servers. Both of those products are alpha, so treat the date on this paragraph as its expiry.

Trust signals

Fair critique from Reddit: a new repo claiming "actively maintained" with no visible tests is worth exactly zero trust. Here's what's actually verifiable:

  • 1900+ tests (node --test) covering every tool's input validation, API shape, and error handling. Run npm test to see them pass locally.
  • Local release flow via release.sh: lint + test + bump + tag + push + npm publish + MCP Registry publish, all from the workstation. No CI workflow to babysit.
  • Dependabot alerts surface on this repo and get fixed, not ignored.
  • Every tool names a real endpoint from the OpenAPI spec. If it's in the tool list, it calls a path documented in the current v2 API -- no placeholder 404 tools. To be clear about the limits of that: no recorded live exchange ships with this repo (fixtures/live/ is empty on purpose), and no claim here rests on an observation against a live tailnet.

Issues and PRs are triaged. File one if something is off — github.com/YawLabs/tailscale-mcp/issues.

Quick start

1. Set your API key

Get an API key from Tailscale Admin Console > Settings > Keys and set it where your MCP client will see it. The .mcp.json env block in step 2 works identically on every platform and is the option to prefer; to export it from a shell profile instead (~/.bashrc, ~/.zshrc, ~/.config/fish/config.fish):

macOS / Linux / WSL (bash, zsh):

bash
export TAILSCALE_API_KEY="tskey-api-..."

fish:

fish
set -Ux TAILSCALE_API_KEY tskey-api-...

Windows (PowerShell 5.1 and 7) — [Environment]::SetEnvironmentVariable persists it for the user, where $env: alone lasts only for the session:

powershell
[Environment]::SetEnvironmentVariable('TAILSCALE_API_KEY', 'tskey-api-...', 'User')

2. Create .mcp.json in your project root

macOS / Linux / WSL:

json
{  "mcpServers": {    "tailscale": {      "command": "npx",      "args": ["-y", "@yawlabs/tailscale-mcp@latest"]    }  }}

Windows:

json
{  "mcpServers": {    "tailscale": {      "command": "cmd",      "args": ["/c", "npx", "-y", "@yawlabs/tailscale-mcp@latest"]    }  }}

Why the extra step on Windows? On Windows, npx is a .cmd file, and Node 20+ refuses to spawn .cmd files directly. Wrapping with cmd /c is the standard workaround.

3. Restart and approve

Restart Claude Code (or your MCP client) and approve the Tailscale MCP server when prompted.

That's it. Now ask your agent:

"List my Tailscale devices that haven't been seen in the last 7 days"

"Summarize every ACL change in the audit log from yesterday"

"Draft an ACL rule that lets tag:ci reach tag:registry on port 5000 only"

Too many tools? Subset them.

97 tools is a lot. If you've already got a dozen MCP servers and your client is feeling heavy, trim what this one exposes. Three knobs, combinable:

The env blocks below show only the variable under discussion. Your credentials come from the environment, as set in Quick start — keep them in your shell profile rather than in the client's JSON config, which is world-readable on most systems and easy to commit by accident.

Option 1: TAILSCALE_PROFILE (preset, easiest)

json
{  "env": {    "TAILSCALE_PROFILE": "core"  }}
  • minimal (20 tools) — status, devices, audit. Observe the tailnet, read the audit log.
  • core (52 tools) — adds acl, dns, keys, users. The day-to-day admin surface.
  • full (97 tools, default) — everything. Same as omitting the env var.

Profile names are case-insensitive and ignore surrounding whitespace (Core selects core). The group names in TAILSCALE_TOOLS and TAILSCALE_WRITE_GROUPS are case-sensitive.

Option 2: TAILSCALE_TOOLS (explicit group list)

json
{  "env": {    "TAILSCALE_TOOLS": "devices,acl,dns,audit"  }}

Comma-separated group names. Overrides TAILSCALE_PROFILE when both are set — use this when the presets aren't quite right.

Valid group names: status, devices, acl, dns, keys, users, tailnet, org-tailnets, webhooks, posture, audit, invites, services, log-streaming. The local-cli group is also available, but only when TAILSCALE_LOCAL_CLI=1 is set — see Local CLI integration.

Option 3: TAILSCALE_READONLY (drop mutations)

json
{  "env": {    "TAILSCALE_PROFILE": "core",    "TAILSCALE_READONLY": "1"  }}

Set to 1 or true to drop every tool without readOnlyHint: true. Stacks with TAILSCALE_PROFILE or TAILSCALE_TOOLS as an intersection — combine for maximum minimalism.

Confirming what loaded

The server logs the active filter to stderr on startup:

@yawlabs/tailscale-mcp v0.22.0 ready (20 tools, profile=minimal, readonly)

When both TAILSCALE_PROFILE and TAILSCALE_TOOLS are set, TAILSCALE_TOOLS wins. The banner marks the profile as overridden so the precedence is obvious at a glance — no need to guess which filter actually applied:

@yawlabs/tailscale-mcp v0.22.0 ready (22 tools, profile=core (overridden by TAILSCALE_TOOLS), groups=devices,acl)

The "(overridden)" marker only fires for substantive profiles (minimal / core); profile=full is a no-op preset, so it's shown without the marker when TAILSCALE_TOOLS is also set.

If you don't set any filter, startup prints a tip pointing you at the profiles.

And how the agent knows

Everything above is stderr -- your MCP client's log. The model never sees it, so a withheld tool and a tool that was never built look identical from the agent's side. That is how an agent ends up working around a restriction instead of reporting it.

tailscale_tool_groups closes that gap. It is always registered, whatever the filters say, and answers the question in-band:

> "Why can't you delete that device?"
  tailscale_tool_groups({ toolName: "tailscale_delete_device" })
  {    "tool": "tailscale_delete_device",    "available": false,    "group": "devices",    "kind": "write",    "reason": "TAILSCALE_WRITE_GROUPS is set to \"dns\", which does not grant writes here",    "toEnable": "add \"devices\" to TAILSCALE_WRITE_GROUPS (e.g. \"dns,devices\")"  }

It separates the three cases an agent otherwise cannot tell apart:

CaseWhat the agent should do
No such tool exists, under any configurationFind another approach -- no setting will produce it
Exists, but its group is not loadedReport toEnable to you; do not work around it
Exists and loaded, but writes are withheld thereSame -- the fix is yours, not a workaround

Called with no arguments it lists every group with its availability and, for anything withheld, the exact environment change that would restore it. It reads no network and needs no credentials, so it works even when the server is misconfigured.

Scoping writes to areas

TAILSCALE_WRITE_GROUPS names the areas an agent may write to. Everything else stays readable:

json
{  "env": {    "TAILSCALE_WRITE_GROUPS": "devices,keys"  }}

That serves all 41 read tools plus the 18 writes in devices and keys, and withholds the other 38 writes — the ACL, DNS, users, tailnet, webhooks, posture, services, invites, org-tailnets and log-streaming writes are simply not registered. Unset means no write gate, which is the shipped default.

Read this first: this filters the tool list, not your API token. The server still holds one credential with full tailnet authority in every configuration. An agent that also has a shell can curl api.tailscale.com with that same token and do everything this knob withheld. Scope the Tailscale OAuth client itself to the areas you actually need (scopes per tool group) — that bound survives outside this process; this one does not. TAILSCALE_WRITE_GROUPS is the low-friction complement to credential scoping, not a replacement for it.

What a grant actually contains

Group names are the same ones TAILSCALE_TOOLS uses. Writes per group:

GroupWritesGroupWrites
devices13webhooks5
invites7posture3
dns6services3
keys5tailnet3
users5log-streaming3
org-tailnets2acl1

status, audit and the opt-in local-cli group contain no writes at all, so granting them does nothing.

devices is the widest grant, and the one most likely to be set. In a compose file write=devices reads like "device admin", but it hands over delete_device, set_devices_authorized, expire_device, deauthorize_device, set_device_routes, set_device_tags and update_device_key alongside rename_device. There is no finer setting: an honest "safe subset" of devices is rename_device alone, and a knob whose useful value is one tool is not a knob.

Three grants are tailnet-admin-equivalent

keys, users and acl are not blocked — CI key rotation legitimately needs keys — but grant them knowing:

  • keys — tailscale_create_key mints an OAuth client with whatever scopes the caller asks for, including policy_file and all. That credential outlives the agent's session and is not subject to this or any other setting here.
  • users — tailscale_update_user_role accepts owner.
  • acl — tailscale_update_acl rewrites policy for every principal in the tailnet.

The server prints this on startup when your grant includes one of them.

What it does and does not bound

It bounds where an agent may write. It does not bound severity within a granted area: inside a granted group, writes run unattended, including the grant-direction ones. Pair it with TAILSCALE_REQUIRE_APPROVAL=1 when a human is at the keyboard — but understand that for an unattended agent that pairing contributes nothing, because a never-prompt client denies those calls rather than prompting.

Precedence, and what happens when you get it wrong

SituationResult
Unset, empty, whitespace, or commas-onlyNo write gate. -e VAR with no value must not silently revoke every write.
TAILSCALE_READONLY=1 also setReadonly wins; banner says readonly (TAILSCALE_WRITE_GROUPS ignored).
A name is misspelled (devises)Grants nothing and names the typo. Unlike TAILSCALE_TOOLS, there is no fallback — a typo'd write grant that fell back would hand over all 56 writes at the moment you were restricting them.
Partly misspelled (devices,dnss)Grants the valid half, warns about the rest.
A granted group is not loaded by TAILSCALE_TOOLS / TAILSCALE_PROFILEThe grant has no effect; a separate warning says so, since the name is not a typo.
none, all, off, *Not reserved words — they are unknown group names, so they grant nothing. Use TAILSCALE_READONLY=1 for no writes, or leave this unset for all writes. The server points you at the right spelling.

Names are case-sensitive, matching TAILSCALE_TOOLS.

The upgrade contract: upgrading this package can never widen the set of areas an agent may write to. A new group is in nobody's grant until a human types its name. It can, however, add tools inside an area you already granted — a pinned test makes that a reviewed line in the diff rather than a silent change.

The startup banner shows what applied:

@yawlabs/tailscale-mcp v0.22.0 ready (59 tools, write=devices,keys)

Requiring approval on irreversible tools

readOnlyHint / destructiveHint are advisory — the MCP spec says clients MUST treat annotations as untrusted, and most don't gate on them. TAILSCALE_REQUIRE_APPROVAL=1 adds a stronger signal that supported clients enforce:

json
{  "env": {    "TAILSCALE_REQUIRE_APPROVAL": "1"  }}

Nine tools are then advertised with _meta["anthropic/requiresUserInteraction"], which forces a confirmation prompt even when an allow-rule would otherwise auto-approve the call:

ToolWhy it's on the list
tailscale_update_aclCan lock every device out of the tailnet; the previous HuJSON (comments included) is gone unless you captured it
tailscale_delete_deviceThe device must re-enroll
tailscale_delete_userNo undelete
tailscale_delete_tailnetDestroys an entire tailnet
tailscale_delete_keyThe secret is never returned again
tailscale_delete_oauth_appSame
tailscale_delete_webhookSame
tailscale_delete_log_stream_configSame
tailscale_delete_posture_integrationSame

The line drawn is "this server cannot undo it with information you still hold", which is narrower than the 23 tools annotated destructiveHint: true. tailscale_suspend_user is deliberately excluded — tailscale_restore_user reverses it. So are tailscale_deauthorize_device (reversed by tailscale_authorize_device) and the replace-all setters, which all have a get_* counterpart you can read before writing.

Opt-in on purpose, and read this before turning it on. In a client mode that never prompts (an unattended agent, a CI run), the flag causes those calls to be denied rather than run. That is the right default when a human is at the keyboard and the wrong one when nobody is, so it stays off unless you set it.

Requires a client that honors the annotation; Claude Code added support in v2.1.199. Clients that don't recognize it ignore it, so setting the variable is never worse than leaving it off.

Separately and always on, the tools whose response size scales with the tailnet rather than with the request — tailscale_list_devices, tailscale_list_users, tailscale_get_acl, tailscale_diff_acl_access, tailscale_get_audit_log, tailscale_get_network_flow_logs, tailscale_local_status — declare _meta["anthropic/maxResultSizeChars"], so a large-but-legitimate result stays inline instead of being truncated into a file reference the agent has to read back mid-task. The last of those is the one entry behind an opt-in: it declares the cap whenever TAILSCALE_LOCAL_CLI=1 registers it, and is absent entirely otherwise.

Using with mcp.hosting / mcph

If you run this server through mcp.hosting (via the @yawlabs/mcph local agent), the two filtering layers compose cleanly:

  1. Server-side — TAILSCALE_PROFILE / TAILSCALE_TOOLS / TAILSCALE_READONLY reduce the tool surface before mcph sees it. The unloaded tools aren't registered at all.
  2. Client-side — mcph's mcp_connect_activate({ tools: [...] }) filters further for what appears in tools/list. Tools not in that list stay reachable via mcp_connect_dispatch, so you don't lose capability.

Recommended pattern for mcph users: set TAILSCALE_PROFILE=core (or narrower) in your mcp.hosting server config, then let mcph handle per-conversation activation on top. The server stays lean by default, and mcp_connect_dispatch covers the long-tail tools for ad-hoc needs.

Authentication

API key (simplest): Set TAILSCALE_API_KEY in your shell or MCP config.

OAuth (scoped access): For fine-grained permissions, set TAILSCALE_OAUTH_CLIENT_ID and TAILSCALE_OAUTH_CLIENT_SECRET instead. Create an OAuth client at Tailscale Admin Console > Settings > Trust credentials, with the scopes listed below for the tool groups you load.

The server checks for an API key first, then falls back to OAuth. If neither is set, tools return a clear error telling you what to configure — the server still starts, so your MCP client doesn't loop restarting.

Tailnet: Uses the credential's own tailnet (-) automatically, which is what most setups want. To name one explicitly, set TAILSCALE_TAILNET to the Tailnet ID shown under Settings > General in the admin console — it looks like T1234CNTRL. Tailnets created before October 2025 can still use their legacy organization name; newer ones have no such name to use. Per the OpenAPI spec, the Tailnet ID is the preferred identifier either way.

TAILSCALE_OAUTH_TAILNET — target an API-only tailnet (one created by tailscale_create_org_tailnet). Those tailnets are not reachable with a plain client-credentials exchange: you authenticate with an OAuth client belonging to the creating tailnet (all scope) and the target rides on the token request. Set this to the new tailnet's id. Deliberately separate from TAILSCALE_TAILNET so the default token exchange is unchanged for everyone else. If you set this, leave TAILSCALE_TAILNET unset (or -) so tool requests follow the token — pointing the two at different tailnets makes every tailnet-scoped tool return 403, and the server warns about it at startup.

OAuth scopes by tool group

The scopes an OAuth client needs for each TAILSCALE_TOOLS group. Grant the Read column for the groups you load, and add the Write column for the ones you let it change; Notes lists what a group needs beyond that. all:read (every read scope) and all (everything) are the broadest grants there are.

GroupReadWriteNotes
statusdevices:core:read, feature_settings:readnoneReads the device list and the tailnet settings, and still returns one when the other is refused.
devicesdevices:core:read, devices:routes:read, devices:posture_attributes:readdevices:core, devices:routes, devices:posture_attributesThe route tools use the devices:routes pair and the posture-attribute tools the devices:posture_attributes pair; the rest use devices:core. A credential holding devices:core must be created with at least one tag.
aclpolicy_file:read, devices:core:read, devices:posture_attributes:readpolicy_file, devices:posture_attributesTailscale requires the device scopes alongside policy_file:read and policy_file. tailscale_diff_acl_access also needs users:read when you omit principals and it lists the users itself.
dnsdns:readdnsUnverified. The OpenAPI spec names no scope on any DNS operation, and the trust credentials doc these come from does not list /dns/configuration, the endpoint behind tailscale_get_dns_configuration and tailscale_set_dns_configuration.
keysauth_keys:read, oauth_keys:read, federated_keys:read, api_access_tokens:read, oauth_apps:readauth_keys, oauth_keys, federated_keys, api_access_tokens, oauth_appsKey scopes go by key type: auth_keys for auth keys, oauth_keys for OAuth clients, federated_keys for federated identities, api_access_tokens for personal API access tokens (read and delete only). Grant only the types you manage; only all:read and all can list every access token in the tailnet. The OAuth-app tools use oauth_apps, and tailscale_create_oauth_app also needs devices:posture_attributes when it sends allowedNodeAttributes.
usersusers:readusers
tailnetfeature_settings:read, account_settings:readfeature_settings, account_settingsSettings are split by field: network flow logging needs logs:network:read / logs:network, HTTPS certificates networking_settings:read / networking_settings, and the two externally-managed-ACL fields policy_file:read / policy_file; feature_settings covers the rest. The contacts tools use account_settings.
org-tailnetstailnets:readtailnetstailscale_delete_tailnet needs all (see TAILSCALE_OAUTH_TAILNET above).
webhookswebhooks:readwebhooks
posturefeature_settings:readfeature_settingsThe same scope governs most tailnet settings, so a client that can manage posture integrations can change those too.
auditlogs:configuration:read, logs:network:readnonetailscale_get_audit_log uses the first, tailscale_get_network_flow_logs the second.
invitesdevice_invites:readdevice_invites (delete only)Creating, resending and accepting a device invite (tailscale_create_device_invite, tailscale_resend_device_invite, tailscale_accept_device_invite) cannot be done with a token from an OAuth client at all, and creating, deleting and resending a user invite (tailscale_create_user_invite, tailscale_delete_user_invite, tailscale_resend_user_invite) is permitted only with a user-owned key. Use TAILSCALE_API_KEY for those. The spec names no scope for reading user invites.
servicesservices:readservicestailscale_list_service_hosts, tailscale_get_service_device_approval and tailscale_set_service_device_approval need both services and devices:core, so the two reads among them do not work on a read-only client.
log-streaminglog_streaming:readlog_streamingStreaming to a private endpoint also needs device_invites and policy_file. tailscale_create_aws_external_id and tailscale_validate_aws_trust_policy both need log_streaming, although the second is a read.
local-clinonenoneRuns the local tailscale binary and makes no admin-API call.

Scopes are taken from Tailscale's OpenAPI spec as of 2026-09-19. The DNS row, which the spec omits, and the device scopes in the acl row come from the trust credentials doc. All of it is read from the documentation, not observed against a tailnet.

Reliability and debugging

429 and gateway-error retry (built-in). HTTP 429, 502, 503 and 504 are retried up to 3 times on the idempotent methods (GET, PUT, DELETE), honoring the Retry-After header (both seconds-integer and HTTP-date forms). Falls back to exponential backoff with jitter, capped at 30s per wait. No env var needed — this is on by default. Workflows like "rotate every key older than 90 days" no longer fail mid-loop on Tailscale's per-tenant rate limits, and a gateway blip no longer fails a whole tool call: per the OpenAPI spec, 504 is documented on every device and service operation with the message "request took too long to process, please try again later", and 502 on the log reads. HTTP 500 is not retried — it means the server failed to process the request, not that something in front of it gave up. POST and PATCH are never retried, on any status. A DELETE that retried past a gateway error and then got a 404 says so in its error, because the attempt that timed out may already have deleted the resource.

TAILSCALE_DEBUG=1 — log every HTTP method, URL, status, and elapsed time to stderr. Authorization headers are never logged. Use this when a tool returns an unexpected error and you want to see the actual request that went out. Example:

[tailscale-mcp] GET https://api.tailscale.com/api/v2/tailnet/-/devices[tailscale-mcp]   <- 200 (148ms)

TAILSCALE_MAX_CONCURRENT=N — cap in-flight API requests at N. Default is unlimited (no behavior change for users who don't opt in). Useful when an agent fans out aggressively against a tailnet that has stricter limits than the per-call retry can absorb.

TAILSCALE_REQUEST_BUDGET_MS=N — total wall-clock budget per request, including retries and their sleeps. Default 90000 (90s). When the next retry's predicted wall time would exceed the budget, the call surfaces the error immediately instead of holding the line. For a gateway 5xx that prediction also charges the duration of the attempt that just failed: a 504 arrives only after the gateway has already waited, so the retry most likely costs the same again, and spending the rest of the budget on it would leave your client with silence instead of the 504. A call that retries past a gateway 5xx is also held to half this budget from that point on — 45s by default, under the 60s low end of the usual MCP client timeout — since those attempts cost gateway wait time rather than backoff, and a chain of them can outlast the client while a 429 chain cannot. Raising this value raises that ceiling with it; a 429 chain keeps the whole budget either way. Tune lower if your MCP client has a tighter outer timeout. Non-idempotent methods (POST, PATCH) are never retried — those return immediately regardless of budget.

TAILSCALE_RETRY_BASE_DELAY_MS=N — base delay for the exponential backoff between retries; attempt N waits base * 2^N (capped at 30s, plus jitter). Default 1000 (1s), so a fully-exhausted retry chain spends roughly 1s + 2s + 4s sleeping. Pairs with TAILSCALE_REQUEST_BUDGET_MS: lowering the budget on its own doesn't get you more retries, it just makes the default backoff exhaust the budget sooner and give up. Shrink both if you want "retry hard, fail fast". A server-supplied Retry-After header always wins over this value.

TAILSCALE_EXTRA_WEBHOOK_EVENTS=eventA,eventB — opt-in escape hatch for webhook event types Tailscale ships after the latest release of this package. The webhook tools validate subscriptions against a strict static catalog so typos and stale event names fail fast with a clear error; if you need a brand-new event before the catalog catches up, list it here (comma-separated) and the schema will accept it. The two category subscriptions (categoryTailnetManagement, categoryDeviceMisconfigurations) are in the catalog, so they need no entry here. Please also open an issue so the static list catches up.

TAILSCALE_EXTRA_POSTURE_PROVIDERS=providerA,providerB — the same escape hatch for device-posture integration providers. tailscale_create_posture_integration validates provider against a static list (falcon, fleet, huntress, intune, jamfpro, kandji, kolide, sentinelone); if Tailscale adds one before this package catches up, list it here rather than waiting for a release. This field used to be a closed enum, which made a newly-supported provider uncreatable rather than merely unvalidated.

Friendlier error messages. JSON error bodies of the form {"message":"..."} or {"error":"..."} are unwrapped before display, so you see the prose explanation instead of raw JSON. When the body also carries a data array — which the ACL endpoints use to report a failing policy test — it is rendered under the message, so a rejected policy says which user and which assertion failed instead of just test(s) failed. 401s still get the full multi-line auth-error formatter (with the Windows env-var hint when applicable).

Local CLI integration (opt-in)

Most tools talk to the Tailscale v2 admin API — they describe the tailnet. Sometimes you want to ask about this machine's view: is it actually connected? What DERP region is it on? How far is my-laptop from here? Those answers come from the local tailscale binary, not the admin API.

Set TAILSCALE_LOCAL_CLI=1 (in your shell or .mcp.json env block) to add 6 read-only diagnostic tools:

ToolEquivalent CLI commandUse it for
tailscale_local_statustailscale status --json [--peers=false] [--active]This machine's connection state + peers it can see; peers: false and activeOnly: true narrow the peer map
tailscale_pingtailscale ping <target>Latency probe to another tailnet node (direct vs DERP-relayed)
tailscale_netchecktailscale netcheck --format=jsonNAT type, DERP latency map, IPv4/IPv6 support
tailscale_local_versiontailscale versionWhich client version is actually running
tailscale_local_whoamitailscale whoamiWhich user and device this machine is authenticated as (needs tailscale >= 1.102.1)
tailscale_local_service_listtailscale service listTailscale Services visible to this node (needs tailscale >= 1.102.1)

Requirements: the tailscale binary has to be findable. It's looked up on PATH first, then at the default install paths below, and TAILSCALE_BINARY overrides both with an absolute path of your choosing.

PlatformWhere it looks beyond PATHNotes
macOS/Applications/Tailscale.app/Contents/MacOS/Tailscale, /opt/homebrew/bin/tailscale, /usr/local/bin/tailscaleThe standard install keeps the CLI inside the app bundle and adds nothing to PATH. An MCP client launched from the Dock or Spotlight also inherits a minimal PATH, not your shell's — so a bare lookup can fail even when tailscale works in your terminal.
Linux/usr/bin/tailscale, /snap/bin/tailscaleThe snap wrapper is outside some minimal PATHs.
Windows—The installer puts tailscale.exe on the machine PATH. If you set TAILSCALE_BINARY, use a Windows path (C:/Program Files/Tailscale/tailscale.exe), not a Git Bash one (/c/...) — that spelling is translated when you type it at an MSYS prompt, but not when it's read from a JSON config or a .env.
WSL/usr/bin/tailscale, /snap/bin/tailscaleThese tools report the Linux node, and need Tailscale installed inside the distro with tailscaled running there. In a fresh WSL install the only tailscale in reach is the Windows one; a Linux process can't exec tailscale.exe, and pointing TAILSCALE_BINARY at /mnt/c/.../tailscale.exe would report the Windows host's Self, peers, whoami identity and netcheck results while every tool here says "this machine's". tailscale.exe is deliberately never picked up automatically.

The MCP server doesn't need root to run these — they're all diagnostic, not state-mutating. Operations that would need elevation (tailscale up, set --advertise-routes, lock sign) are deliberately not exposed.

When opt-in is on, the startup banner reflects it: @yawlabs/tailscale-mcp v0.22.0 ready (103 tools, local-cli=on) — the 6 local CLI tools are additive on top of the default 97.

Resources (4)

MCP Resources expose read-only data clients can browse without a tool call.

ResourceURIDescription
Tailnet Statustailscale://tailnet/statusDevice count and tailnet settings
Devicestailscale://tailnet/devicesAll devices with status and IPs
ACL Policytailscale://tailnet/aclFull ACL policy (HuJSON preserved)
DNS Configtailscale://tailnet/dnsNameservers, search paths, split DNS, MagicDNS

Tools (97 + 6 opt-in)

Status (1 tool)
ToolDescription
tailscale_statusVerify API connection, see tailnet info and device count
Devices (17 tools)
ToolDescription
tailscale_list_devicesList devices (default field subset; fields: "all" adds routes, connectivity, SSH, distro, posture identity). lastSeen is absent while a device is online
tailscale_get_deviceGet one device (fields: "all" for the full record)
tailscale_authorize_deviceAuthorize a pending device
tailscale_deauthorize_deviceDeauthorize a device
tailscale_set_devices_authorizedAuthorize/deauthorize many devices in one call (parallel, per-id error reporting)
tailscale_delete_deviceRemove a device from the tailnet
tailscale_rename_deviceRename a device (FQDN or base name; empty string resets to the OS hostname)
tailscale_expire_deviceExpire a device's key, forcing re-authentication
tailscale_get_device_routesGet advertised and enabled subnet routes
tailscale_set_device_routesEnable or disable subnet routes
tailscale_get_device_posture_attributesGet all posture attributes for a device
tailscale_set_device_posture_attributeSet a custom posture attribute (optional expiry and audit-log comment)
tailscale_delete_device_posture_attributeDelete a custom posture attribute
tailscale_set_device_tagsSet ACL tags on a device
tailscale_set_device_ipSet a device's Tailscale IPv4 address
tailscale_update_device_keyUpdate device key settings (e.g. disable key expiry)
tailscale_batch_update_posture_attributesBatch update custom posture attributes across devices
ACL / Policy (5 tools) — with HuJSON formatting preservation and ETag safety
ToolDescription
tailscale_get_aclGet ACL policy with formatting preserved (HuJSON) + ETag
tailscale_update_aclUpdate ACL policy (requires ETag for safe concurrent edits; ts-default for a first write)
tailscale_validate_aclValidate a policy without applying it
tailscale_preview_aclPreview rules that would apply to a user or IP
tailscale_diff_acl_accessCompare a proposed policy against the live one — who gains and loses access
DNS (11 tools)
ToolDescription
tailscale_get_nameserversGet DNS nameservers
tailscale_set_nameserversSet DNS nameservers
tailscale_get_search_pathsGet DNS search paths
tailscale_set_search_pathsSet DNS search paths
tailscale_get_split_dnsGet split DNS configuration
tailscale_set_split_dnsSet split DNS configuration (full replace; null clears a domain)
tailscale_update_split_dnsUpdate split DNS configuration (partial merge; null removes a domain)
tailscale_get_dns_preferencesGet DNS preferences (MagicDNS)
tailscale_set_dns_preferencesSet DNS preferences (MagicDNS)
tailscale_get_dns_configurationGet unified DNS configuration (all settings in one call)
tailscale_set_dns_configurationSet unified DNS configuration (all settings in one call)
Keys / Trust Credentials (9 tools) — covers auth keys, OAuth clients, federated identities, and OAuth apps
ToolDescription
tailscale_list_keysList keys (default set depends on the credential; all=true for tailnet-wide: auth keys, API access tokens, OAuth clients, federated identities)
tailscale_get_keyGet details for a key of any type
tailscale_create_keyCreate an auth key, OAuth client (keyType=client), or federated identity (keyType=federated)
tailscale_delete_keyDelete a key of any type, including the API access token this server runs on
tailscale_update_keyUpdate a key's description, scopes, tags, or federated claim settings
tailscale_create_oauth_appCreate an OAuth App for third-party device provisioning (Tailscale alpha)
tailscale_get_oauth_appGet an OAuth App's name, redirect URIs, and scopes
tailscale_list_oauth_appsList every OAuth App registered in the tailnet
tailscale_delete_oauth_appDelete an OAuth App, revoking its ability to provision devices
Users (7 tools)
ToolDescription
tailscale_list_usersList all users in the tailnet
tailscale_get_userGet details for a specific user
tailscale_approve_userApprove a pending user
tailscale_suspend_userSuspend a user, revoking access
tailscale_restore_userRestore a suspended user
tailscale_update_user_roleUpdate a user's role (owner, admin, member, etc.)
tailscale_delete_userDelete a user and all their devices
Tailnet Settings (5 tools)
ToolDescription
tailscale_get_tailnet_settingsGet tailnet settings (HTTPS, device approval, key expiry, etc.)
tailscale_update_tailnet_settingsUpdate tailnet settings (HTTPS certificates, approval, auto-updates, key expiry, posture, regional routing, network flow logging, external ACL management)
tailscale_get_contactsGet tailnet contacts
tailscale_set_contactsSet tailnet contacts
tailscale_resend_contact_verificationResend verification email for a contact
Webhooks (7 tools)
ToolDescription
tailscale_list_webhooksList webhooks
tailscale_get_webhookGet a specific webhook
tailscale_create_webhookCreate a webhook (raw JSON, or formatted for Slack / Mattermost / Google Chat / Discord via providerType)
tailscale_update_webhookUpdate a webhook's endpoint URL and/or subscriptions
tailscale_delete_webhookDelete a webhook
tailscale_rotate_webhook_secretRotate a webhook's secret
tailscale_test_webhookSend a test event to verify webhook delivery
Posture Integrations (5 tools)
ToolDescription
tailscale_list_posture_integrationsList posture integrations
tailscale_get_posture_integrationGet a posture integration
tailscale_create_posture_integrationCreate a posture integration
tailscale_update_posture_integrationUpdate a posture integration
tailscale_delete_posture_integrationDelete a posture integration
Tailscale Services (7 tools)
ToolDescription
tailscale_list_servicesList all Tailscale Services in your tailnet
tailscale_get_serviceGet details for a specific service
tailscale_update_serviceUpdate a service's configuration
tailscale_delete_serviceDelete a service
tailscale_list_service_hostsList devices hosting a service
tailscale_get_service_device_approvalGet approval status of a device for a service
tailscale_set_service_device_approvalApprove or reject a device to host a service
Organization Tailnets (3 tools) — API-only tailnets; OAuth authentication required

Create and tear down whole tailnets programmatically — useful for per-agent sandboxes, per-tenant isolation, and ephemeral CI environments. Organizations get 10 tailnets including the original by default. Unlike every other group here these endpoints live under /organizations, authenticate only with an OAuth client (the tailnets scope to create, all to then reach the tailnet), and produce tailnets that are not managed in the admin console. Set TAILSCALE_OAUTH_TAILNET to operate on one.

ToolDescription
tailscale_list_org_tailnetsList the organization's tailnets (paginated via limit / cursor)
tailscale_create_org_tailnetCreate an API-only tailnet; returns its OAuth client secret once
tailscale_delete_tailnetDelete a tailnet (the configured one, or an explicit tailnet) — irreversible; requires confirmTailnet to match
Log Streaming (7 tools)
ToolDescription
tailscale_list_log_stream_configsList log streaming configurations (both audit and network)
tailscale_get_log_stream_configGet log streaming config for a log type
tailscale_set_log_stream_configSet where logs are sent (Axiom, Datadog, Splunk, etc.)
tailscale_delete_log_stream_configDelete a log streaming configuration
tailscale_get_log_stream_statusCheck if log streaming is delivering successfully
tailscale_create_aws_external_idCreate/get the AWS external ID for S3 role-based log streaming (reusable, default true, returns the same ID until it is linked)
tailscale_validate_aws_trust_policyValidate AWS IAM role trust policy for S3 log streaming
Device Invites (6 tools)
ToolDescription
tailscale_list_device_invitesList device invites for a specific device
tailscale_create_device_inviteCreate a device invite
tailscale_get_device_inviteGet a device invite
tailscale_delete_device_inviteDelete a device invite
tailscale_accept_device_inviteAccept a device share invitation
tailscale_resend_device_inviteResend a device invite email
User Invites (5 tools)
ToolDescription
tailscale_list_user_invitesList open (not yet accepted) user invites
tailscale_create_user_inviteCreate a user invite
tailscale_get_user_inviteGet a user invite
tailscale_delete_user_inviteDelete a user invite
tailscale_resend_user_inviteResend a user invite email
Logging (2 tools)
ToolDescription
tailscale_get_audit_logGet configuration audit log (who changed what, when); optional server-side actor / target / event filter
tailscale_get_network_flow_logsGet network traffic flow logs between devices
Local CLI (6 tools, opt-in) — see Local CLI integration
ToolDescription
tailscale_local_statusThis machine's view of the tailnet (own connection state, peers, DERP region); narrow with peers: false or activeOnly: true
tailscale_pingLatency probe to another tailnet node from this machine
tailscale_netcheckNAT type, DERP latency map, IPv4/IPv6 support diagnostics
tailscale_local_versionLocal tailscale binary version
tailscale_local_whoamiWhich user and device this machine is authenticated as (needs tailscale >= 1.102.1)
tailscale_local_service_listTailscale Services visible to this node (needs tailscale >= 1.102.1)

GitOps: deploy ACLs from CI

For the simple "deploy ACL from git on merge" workflow, you don't need an MCP server or an agent — use the built-in CLI:

bash
# PR check: validate the proposed policy without touching the tailnetnpx -y @yawlabs/tailscale-mcp@latest validate-acl tailscale/acl.json
# On merge: ETag fetch + validate + deploy with If-Match, fail-closed at every stepnpx -y @yawlabs/tailscale-mcp@latest deploy-acl tailscale/acl.json

Works in any CI system. Set TAILSCALE_API_KEY as an env var; TAILSCALE_TAILNET is optional — leave it unset to act on the key's own tailnet, or set it to the Tailnet ID to name one explicitly. Both commands exit non-zero on any failure; deploy-acl refuses to deploy without an ETag (so a concurrent Admin Console edit can never be silently clobbered) and reports a 412 as a concurrent-edit conflict you resolve by re-running.

When validation reports a failing policy test, the CI log names the user and the assertion (For user [email protected]: / Errors found:), the same detail upstream's gitops-pusher prints. Validation warnings — a SCIM group that is not syncing, for instance — fail the run too, matching gitops-pusher and Tailscale's own Go client; their text is printed alongside so you can see what was flagged.

A complete GitHub Actions workflow — validate on PR, deploy on merge:

yaml
name: tailscale-aclon:  pull_request:    paths: ["tailscale/acl.json"]  push:    branches: [main]    paths: ["tailscale/acl.json"]
jobs:  acl:    runs-on: ubuntu-latest    env:      TAILSCALE_API_KEY: ${{ secrets.TAILSCALE_API_KEY }}      TAILSCALE_TAILNET: T1234CNTRL # Tailnet ID from Settings > General; or omit: defaults to the key's tailnet    steps:      - uses: actions/checkout@v4      - uses: actions/setup-node@v4        with: { node-version: 22 }      - name: Validate ACL        if: github.event_name == 'pull_request'        run: npx -y @yawlabs/tailscale-mcp@latest validate-acl tailscale/acl.json      - name: Deploy ACL        if: github.event_name == 'push'        run: npx -y @yawlabs/tailscale-mcp@latest deploy-acl tailscale/acl.json

For reproducible deploys, replace @latest with a pinned version.

If you hand-roll this with curl instead: Tailscale's ACL endpoint only returns the ETag header on GET, not HEAD. A curl -I (HEAD) ETag fetch silently yields an empty value — and an empty If-Match either deploys unguarded (clobbering concurrent edits) or trips your guard and fails the deploy. Fetch the ETag with a GET (curl -fsS -D - -o /dev/null ...), and fail the job if it comes back empty. The CLI above does all of this for you.

Optional: Lock the Admin Console to prevent manual edits that drift from git. Ask your agent:

"Set aclsExternallyManagedOn to true and aclsExternalLink to our repo URL"

This shows a read-only banner in the Tailscale Admin Console pointing to your repo. Use the MCP for reads and investigations, and let CI handle the deploy.

Requirements

  • Node.js 20.11+ to run the server (22+ to develop — the test script passes a glob to node --test, supported from Node 21)
  • A Tailscale API key or OAuth client credentials

Running on oam.js (optional)

oam.js runs this server unmodified, and the tailscale-mcp command only ever uses the latest oam release, currently 0.20.2. Verified against the published oam 0.20.2: full MCP handshake, all 97 admin-API tools plus tailscale_tool_groups, all 4 resources, identical error responses, and a clean stdout protocol stream — from the shipped bundle and straight from the TypeScript source with no build step.

oam 0.20.2 is the minimum. A floor matters here: releases before 0.9.0 ran child_process.execFile arguments through a shell, re-splitting them on whitespace and executing shell metacharacters inside an argument, and this server shells out to the tailscale binary across its local-CLI tools, so that was a reachable bug rather than a theoretical one.

How the tailscale-mcp command (bin/tailscale-mcp.mjs) picks a runtime:

  • TAILSCALE_MCP_RUNTIME=auto (the default) — if a client already launched it with oam run on oam 0.20.2 or newer, the server runs in that process. Otherwise it uses OAM_BIN when that is 0.20.2 or newer, else asks every oam binary it can find — OAM_INSTALL_DIR when that is set, then %LOCALAPPDATA%\oam\bin and ~/.oam/bin on Windows, ~/.oam/bin elsewhere, then PATH — for its version and uses the newest at or above the floor (on a tie the installed copy wins). With none, it runs on Node. An oam host older than 0.20.2 never serves the server itself: it hands off to the newest usable oam, or to Node on PATH, or exits with an error when there is neither. Whenever it looks for an oam, stderr names an OAM_BIN that was passed over and why; the oam binaries it found and passed over are named, each with its reason, only when no usable oam turns up.
  • TAILSCALE_MCP_RUNTIME=oam — the same, but exit with an error instead of falling back to Node. The error names the remedy for what it actually found: oam self-update for an oam older than the floor, a check of the binary for one that would not run, and installing oam only when none was found (and on linux-arm64, which oam publishes no build for, not even then).
  • TAILSCALE_MCP_RUNTIME=node — always Node: in-process under npx, handed off to Node on PATH when a client launches the command with oam run.

The value is case-insensitive and surrounding whitespace is ignored; anything else is warned about on stderr and treated as auto. On Windows only oam.exe counts: an oam.cmd / oam.bat shim is never run, and it is named on stderr only when no usable oam turns up.

Sandboxing (opt-in)

Set TAILSCALE_MCP_SANDBOX=1 to run under oam's --permission model: network restricted to api.tailscale.com:443 -- the only host the bundle contacts, including the OAuth token exchange, and every request is HTTPS -- and filesystem denied. Child-process stays granted because the local-CLI tools shell out to the tailscale binary. That child inherits the server's environment, which under the sandbox holds only the granted variables, so besides the TAILSCALE_* settings the allow-list carries PATH (to find the binary) and the variables a Windows program needs to start -- SYSTEMROOT, WINDIR, SYSTEMDRIVE, TEMP/TMP, USERPROFILE, HOMEDRIVE/HOMEPATH, APPDATA, LOCALAPPDATA -- plus HOME. oam takes even the variables Windows adds to every child from that filtered environment, so without them the CLI started with no SYSTEMROOT. oam matches these names exactly, case included, so on Windows the launcher also grants each one in the spelling your environment uses (Path, SystemRoot, SystemDrive, windir when a client inherits them from Explorer).

Under the sandbox, TAILSCALE_BINARY must point at the native tailscale CLI, not at a Node-based wrapper script: oam hands its permission flags to every child through NODE_OPTIONS, as Node does, and Node refuses --allow-net and --allow-env there and exits before running anything. The native CLI ignores the variable.

It is opt-in rather than default because a wrong grant does not fail loudly. oam denies a non-granted environment variable by making it absent from process.env rather than throwing, so an under-granted TAILSCALE_API_KEY reads as "unauthenticated" rather than "denied". The env allow-list in the launcher is derived from what the shipped bundle actually reads -- if you add a new process.env lookup, extend that list with it.

The sandbox is applied by the tailscale-mcp command, which spawns a fresh oam for it -- even when a client launched the command with oam run -- because --permission is a process-level flag. If it finds no usable oam to spawn, TAILSCALE_MCP_RUNTIME=auto still starts the server, without the sandbox; set TAILSCALE_MCP_RUNTIME=oam to make that an error. TAILSCALE_MCP_RUNTIME=node runs on Node, so it never applies the sandbox.

The sandbox applies to the CLI subcommands too, and with the filesystem denied tailscale-mcp validate-acl <file> / deploy-acl <file> cannot read the policy file. Unset TAILSCALE_MCP_SANDBOX for those commands -- for example, if you export it in a shell profile for the server, run TAILSCALE_MCP_SANDBOX= tailscale-mcp validate-acl policy.hujson.

jsonc
{  "mcpServers": {    "tailscale": {      "command": "oam",      "args": ["run", "/path/to/tailscale-mcp/dist/index.js"]    }  }}

Measure startup on your own hardware. An MCP client cold-starts this server once per session, so startup is the cost that actually gets paid, and on the machine this was measured on node won it — 437ms vs 1554ms for oam run over 10 warmed runs (an earlier 5-run round showed 326ms vs 427ms; the box was busy, so treat the magnitude as noisy and the direction as the finding). Those runs were taken with an oam older than 0.18.0 and have not been repeated since, so do not read them as a current ranking.

The published tailscale-mcp command prefers the newest usable oam it finds (see above). Without oam that costs almost nothing: discovery is file-existence checks only, never a subprocess, and the fallback runs the server inside the Node process npm already started. With oam installed, though, the command boots Node, runs --version on every oam binary it found to pick the newest, and only then boots oam, so it is always slower than pointing your client at a runtime directly — the config above for oam, node /path/to/tailscale-mcp/dist/index.js for Node. TAILSCALE_MCP_RUNTIME=node skips oam entirely.

Two places oam does win for this repo, both opt-in and neither touching the npm package:

  • npm run check:oam — type-checks via oam check (tsgo, TypeScript 7 native). Measured 4015ms against 7680ms for tsc --noEmit, same clean result. npx tsc --noEmit remains the portable default.
  • npm run build:binary:oam — builds the standalone binary via oam compile (~57.7 MB measured). Writes bin/<platform>-<arch>/ (or bin/$TAILSCALE_MCP_BINARY_TARGET/ for a cross-build), which scripts/stage-release-asset.mjs then stages under the public asset name. If you redistribute that binary it embeds oam's runtime, so ship oam's LICENSE, NOTICE and THIRD_PARTY_LICENSES.md with it. A cross-build (TAILSCALE_MCP_BINARY_TARGET=<platform>-<arch>) downloads the target's oam release binary as its carrier and checks it against the release's signed RELEASE-MANIFEST, verified with ssh-keygen -Y verify (OpenSSH 8.1+) against oam's release keys in scripts/oam-release-keys/; it aborts when the signature, the manifest or the checksum does not check out. An OAM_VERSION below v0.18.0, released before oam signed its releases, is checked against its SHA256SUMS only once that file matches the digest pinned for the tag in scripts/oam-release-keys/presigning-sums.

The source stays runtime-agnostic on purpose: no oam: imports anywhere, and tests stay on node:test. That is what keeps the Node fallback real rather than nominal. Note that any oam invocation writes a bytecode cache to oam/ in the working directory — already in .gitignore.

Contributing

Contributions welcome. See CONTRIBUTING.md for the PR workflow and AI-agent guidelines. Please open an issue to discuss before a PR for anything beyond a typo fix.

bash
git clone https://github.com/YawLabs/tailscale-mcp.gitcd tailscale-mcpnpm installnpm run lint       # Biome checknpm run lint:fix   # Auto-fixnpm run build      # tsc + esbuild bundlenpm test           # node --test (full suite)

For integration testing against your own tailnet: set TAILSCALE_API_KEY and run node dist/index.js.

Security

Found a vulnerability? See SECURITY.md — please use GitHub's private vulnerability reporting, not a public issue.

License

MIT

[Follow @YawLabs on X]

来源:README.md,提交 03ce9f5

工具

98

tailscale_tool_groups

Explain available tools

Explain which of this server's tools are available and why. Call this FIRST when a Tailscale tool you expected is missing, instead of assuming the capability does not exist -- tools can be withheld by configuration, and the fix is usually one environment variable. Pass `toolName` to ask about one specific tool (e.g. 'tailscale_delete_device'): the answer distinguishes 'no such tool exists' -- where you should find another approach -- from 'it exists but its group is not loaded' and 'it exists and loaded but writes are withheld there', both of which the operator can enable and neither of which you should work around. With no arguments it lists every group with its availability and, where something is withheld, the exact environment change that would restore it. Always available regardless of filters.

输入参数toolName

tailscale_status

Check API status

Check that the Tailscale API connection is working. Returns your tailnet name, device count, and confirms authentication is valid. Use this to verify setup.

无需输入参数。

tailscale_list_devices

List devices

List all devices in your tailnet with their status, IP addresses, OS, and last seen time. 'lastSeen' is omitted while a device is connected (connectedToControl: true) and for devices that have never been online -- on a connected device a missing lastSeen means online now, not never seen.

输入参数fieldsfilters

tailscale_get_device

Get device

Get detailed information about a specific device by its ID. Returns the default field subset unless fields: 'all'. 'lastSeen' is omitted while a device is connected (connectedToControl: true) and for devices that have never been online -- on a connected device a missing lastSeen means online now, not never seen.

输入参数fieldsdeviceId必填

tailscale_authorize_device

Authorize device

Authorize a device that is pending authorization.

输入参数deviceId必填

tailscale_deauthorize_device

Deauthorize device

Deauthorize a device, immediately removing its access to the tailnet. The device will need to be re-authorized to reconnect.

输入参数deviceId必填

tailscale_delete_device

Delete device

Permanently remove a device from the tailnet. This is irreversible -- the device must re-authenticate to rejoin.

输入参数deviceId必填

tailscale_rename_device

Rename device

Set the name of a device in the tailnet, or reset it to its OS hostname.

输入参数name必填deviceId必填

tailscale_expire_device

Expire device key

Expire a device's key, forcing it to re-authenticate.

输入参数deviceId必填

tailscale_get_device_routes

Get device routes

Get the subnet routes a device advertises and which are enabled.

输入参数deviceId必填

tailscale_set_device_routes

Set device routes

Set the enabled subnet routes for a device. Replaces all currently enabled routes -- pass the full list of routes you want enabled.

输入参数routes必填deviceId必填

tailscale_get_device_posture_attributes

Get device posture attributes

Get all posture attributes for a device, including custom and system-managed attributes.

输入参数deviceId必填

tailscale_set_device_posture_attribute

Set device posture attribute

Set a custom posture attribute on a device. Creates or updates the attribute. Attribute keys must start with 'custom:'. Useful for compliance tracking, JIT access, and custom security policies.

输入参数value必填expirycommentdeviceId必填attributeKey必填

tailscale_delete_device_posture_attribute

Delete device posture attribute

Delete a custom posture attribute from a device. This is irreversible.

输入参数deviceId必填attributeKey必填

tailscale_set_device_tags

Set device tags

Set ACL tags on a device. Replaces all existing tags -- pass the full list of tags you want applied.

输入参数tags必填deviceId必填

tailscale_set_device_ip

Set device IP

Set the Tailscale IPv4 address for a device.

输入参数ipv4必填deviceId必填

tailscale_update_device_key

Update device key

Update a device's key settings, such as disabling key expiry. Useful for servers that should never need to re-authenticate.

输入参数deviceId必填keyExpiryDisabled必填

tailscale_set_devices_authorized

Set devices authorized (bulk)

Authorize or deauthorize multiple devices in one call. Each device's POST runs in parallel; per-device errors are returned alongside the successes so a partial failure doesn't lose the work that succeeded. On partial failure the call still returns success (ok) with data: { authorized, succeeded, failed } -- inspect data.failed for the per-device errors. POSTs are never retried, so on a large batch a rate-limited device lands in data.failed with status 429: re-call with just those ids, or set TAILSCALE_MAX_CONCURRENT to cap requests in flight. Common use: authorize a batch of newly-enrolled CI hosts, or deauthorize a group of devices flagged by a security review.

输入参数deviceIds必填authorized必填

tailscale_batch_update_posture_attributes

Batch update posture attributes

Batch update custom posture attributes across multiple devices. Each attribute key must start with 'custom:'. Uses JSON Merge Patch semantics -- pass null as the attribute config to delete.

输入参数nodes必填comment

tailscale_get_acl

Get ACL policy

Get the current ACL policy for your tailnet. Returns the raw policy text with original formatting preserved, including comments and trailing commas (HuJSON). Also returns an ETag -- you must pass it to tailscale_update_acl to safely update the policy.

无需输入参数。

tailscale_update_acl

Update ACL policy

Update the ACL policy for your tailnet. Accepts the full policy as a string to preserve formatting, comments, and trailing commas (HuJSON). You MUST pass the ETag from tailscale_get_acl to prevent overwriting concurrent changes, or `ts-default` for the first write to a tailnet nobody has edited yet. Always get the current ACL first, make targeted edits to the text, and pass the full modified text back.

输入参数etag必填policy必填

tailscale_validate_acl

Validate ACL policy

Validate an ACL policy without applying it. Returns any errors found, or confirms the policy is valid.

输入参数policy必填

tailscale_preview_acl

Preview ACL rules

Preview the ACL rules that would apply to a specific user or IP address if a proposed policy were applied.

输入参数type必填policy必填previewFor必填

tailscale_diff_acl_access

Diff ACL access

Answer 'who loses access?' before applying an ACL change. Compares the CURRENT policy against a proposed one and reports, per user, which destinations they gain and lose. Run this before tailscale_update_acl -- validate_acl only checks syntax and the policy's own tests block, so a policy with no tests validates clean while revoking everyone. LIMITS, all reported in the response rather than left to be discovered. It compares USER principals only, so a revocation that runs through a tag or group can show a clean diff, and an empty result is never proof a change is safe. Posture DEFINITION changes ARE detected: posture names are resolved to their rules, so tightening `posture:corp` shows as a change -- except when a preview omits the definitions map, where it falls back to comparing names. It costs two preview requests per user, so it checks the first 25 by default and stops starting new users after 60 seconds (a user whose previews are already in flight still finishes); either way it sets `truncated`, reports how many were skipped, and says which limit stopped it. Users whose preview fails are listed in `failed` and excluded from the compared count -- a failure is never reported as lost access, and if nothing could be compared the call fails rather than returning an empty diff.

输入参数policy必填principalsmaxPrincipals

tailscale_get_nameservers

Get nameservers

Get the DNS nameservers configured for your tailnet.

无需输入参数。

tailscale_set_nameservers

Set nameservers

Set the DNS nameservers for your tailnet. Replaces all existing nameservers. Removing every nameserver may also change MagicDNS: the API reference says it is switched off, while Tailscale's current MagicDNS docs say a nameserver is no longer required -- check `magicDNS` in the response.

输入参数dns必填

tailscale_get_search_paths

Get DNS search paths

Get the DNS search paths configured for your tailnet.

无需输入参数。

tailscale_set_search_paths

Set DNS search paths

Set the DNS search paths for your tailnet. Replaces all existing search paths.

输入参数searchPaths必填

tailscale_get_split_dns

Get split DNS

Get the split DNS configuration for your tailnet.

无需输入参数。

tailscale_set_split_dns

Set split DNS

Set split DNS configuration. Maps domains to specific nameservers. Replaces the entire split DNS configuration: a domain you leave out is removed, and an empty object clears every domain. Per the API reference, setting a domain to null clears that domain's nameservers.

输入参数splitDns必填

tailscale_get_dns_preferences

Get DNS preferences

Get DNS preferences for your tailnet, including whether MagicDNS is enabled.

无需输入参数。

tailscale_set_dns_preferences

Set DNS preferences

Set DNS preferences for your tailnet, such as enabling or disabling MagicDNS. The API reference says enabling can fail when the tailnet has no nameservers; if it does, add one with tailscale_set_nameservers first.

输入参数magicDNS必填

tailscale_update_split_dns

Update split DNS (partial)

Partially update split DNS configuration. Merges the provided domains with the existing config -- only the specified domains are changed, others are untouched. To remove a domain, set it to null: that is the idiom the API reference documents. An empty array is also accepted and forwarded as-is -- it is what Tailscale's Terraform provider sends.

输入参数splitDns必填

tailscale_get_dns_configuration

Get DNS configuration (unified)

Get the unified DNS configuration for your tailnet, including nameservers, search paths, split DNS, and MagicDNS preference in a single call.

无需输入参数。

tailscale_set_dns_configuration

Set DNS configuration (unified)

Set the unified DNS configuration for your tailnet in a single call. Replaces all DNS settings (nameservers, search paths, split DNS, MagicDNS preference). This is a replace-all endpoint: pass every top-level field you want to keep, because a field you omit may be cleared rather than left alone.

输入参数dnsmagicDNSsplitDnssearchPaths

tailscale_list_keys

List keys

List keys in your tailnet: auth keys, API access tokens, OAuth clients and federated identities. Without 'all', what comes back depends on the credential this server runs on -- a user-owned API key sees only that user's keys (including the API access token the server itself is using, keyType 'api'); an OAuth-client token sees the tailnet's OAuth clients; a federated-identity token sees its federated identities. Set 'all' to true for the tailnet-wide list (needs the matching :read scopes; only 'all:read' and 'all' return every API access token).

输入参数all

tailscale_get_key

Get key

Get details for a specific key (auth key, API access token, OAuth client, or federated identity). A revoked or expired key is still returned, with `invalid: true`.

输入参数keyId必填

tailscale_create_key

Create key

Create a new key in your tailnet. Supports auth keys (for adding devices), OAuth clients (for programmatic API access), and federated identities (for OIDC-based CI/CD access). Returns the key value -- save it immediately, as it cannot be retrieved again. SECURITY: the response body contains a long-lived credential verbatim. MCP clients commonly persist tool responses to logs and conversation transcripts; treat this response as sensitive (do not commit it, avoid re-sharing it in unrelated chat history). Examples: - Auth key: {keyType:'auth', reusable:true, tags:['tag:ci']} - OAuth client: {keyType:'client', scopes:['devices:core:read','dns:read']} - Federated (GitHub Actions): {keyType:'federated', scopes:['devices:core:read'], issuer:'https://token.actions.githubusercontent.com', subject:'repo:my-org/my-repo:*'}

输入参数tagsissuerscopeskeyTypesubjectaudiencereusableephemeraldescriptionexpirySecondspreauthorizedcustomClaimRules

tailscale_delete_key

Delete key

Delete a key (auth key, API access token, OAuth client, or federated identity). This is irreversible. For auth keys, devices already authenticated are unaffected but no new devices can use it. For OAuth clients and federated identities, any integrations using them lose access immediately. API access tokens are deletable here too: if keyId is the token this server authenticates with -- it shows up in tailscale_list_keys under API-key auth -- the server revokes its own credential and every later call fails with 401 until it is reconfigured.

输入参数keyId必填

tailscale_update_key

Update key

Update an existing key. Supported fields depend on the key type: all key types accept 'description'; OAuth clients and federated identities additionally accept 'scopes' and 'tags'; federated identities additionally accept 'issuer', 'subject', 'audience', and 'customClaimRules'. For auth keys, pass only 'description' -- the Tailscale API will reject other fields.

输入参数tagskeyId必填issuerscopessubjectaudiencedescriptioncustomClaimRules

tailscale_create_oauth_app

Create OAuth app

Create an OAuth App for device provisioning (Tailscale alpha). Lets a third-party application enroll a device into your tailnet via the authorization-code flow, after a user consents. Returns the app's client secret -- save it immediately, it cannot be retrieved again. SECURITY: the response body contains a long-lived credential verbatim. MCP clients commonly persist tool responses to logs and conversation transcripts; treat this response as sensitive. Use scope 'auth_keys:create:once' (one auth key per authorization, no refresh token) -- the scope Tailscale's device-provisioning guide documents. The API reference's example shows 'auth_keys:create'; this tool does not restrict the value. Distinct from tailscale_create_key with keyType='client', which mints a machine-to-machine OAuth client instead.

输入参数name必填scopes必填redirectUris必填allowedNodeAttributes

tailscale_get_oauth_app

Get OAuth app

Get an OAuth App's configuration (name, redirect URIs, scopes) by its app ID. Use this to verify an app was registered as intended. The client secret is not returned -- it is only available at creation time.

输入参数appId必填

tailscale_list_oauth_apps

List OAuth apps

List the OAuth Apps registered in your tailnet (Tailscale alpha). Returns an `oauthApps` array describing each app (id, name, redirect URIs, scopes). Client secrets are NOT included -- a secret is only returned once, by tailscale_create_oauth_app at creation time. This is how you recover the id of an app you did not record; pass that id to tailscale_delete_oauth_app to revoke it.

无需输入参数。

tailscale_delete_oauth_app

Delete OAuth app

Delete an OAuth App (Tailscale alpha). This is irreversible: the app's client secret stops working immediately and any integration using it loses its device-enrollment path, so no further device can be authorized through it. Devices already enrolled stay in the tailnet, exactly as they do when the auth key that added them is deleted. Use tailscale_list_oauth_apps to find the id.

输入参数appId必填

tailscale_list_users

List users

List all users in your tailnet.

输入参数roletype

tailscale_get_user

Get user

Get details for a specific user.

输入参数userId必填

tailscale_approve_user

Approve user

Approve a pending user, granting them access to the tailnet.

输入参数userId必填

tailscale_suspend_user

Suspend user

Suspend a user, immediately revoking their access to the tailnet. Their devices will be disconnected. Can be reversed with tailscale_restore_user.

输入参数userId必填

tailscale_restore_user

Restore user

Restore a previously suspended user, re-granting them access to the tailnet.

输入参数userId必填

tailscale_update_user_role

Update user role

Update a user's role in the tailnet.

输入参数role必填userId必填

tailscale_delete_user

Delete user

Delete a user from the tailnet. This is irreversible -- the user and all their devices will be removed.

输入参数userId必填

tailscale_get_tailnet_settings

Get tailnet settings

Get your tailnet settings (device approval, key expiry, HTTPS certificates, etc.).

无需输入参数。

tailscale_update_tailnet_settings

Update tailnet settings

Update tailnet settings (device approval, auto-updates, key expiry, HTTPS certificates, network flow logging, regional routing, posture identity collection).

输入参数httpsEnabledusersApprovalOnaclsExternalLinkdevicesApprovalOnregionalRoutingOndevicesAutoUpdatesOnnetworkFlowLoggingOndevicesKeyDurationDaysaclsExternallyManagedOnpostureIdentityCollectionOnusersRoleAllowedToJoinExternalTailnets

tailscale_get_contacts

Get contacts

Get the tailnet contact information (security, support, admin emails).

无需输入参数。

tailscale_set_contacts

Set contacts

Update tailnet contact information. Each provided contact type (account/support/security) is PATCHed in parallel; per-type errors are returned alongside the successes so a partial failure doesn't lose the work that succeeded. On partial failure the response is data: { applied, failed } -- inspect data.failed for per-type error details.

输入参数accountsupportsecurity

tailscale_resend_contact_verification

Resend contact verification

Resend the verification email for a tailnet contact.

输入参数contactType必填

tailscale_list_org_tailnets

List organization tailnets

List the tailnets in your organization, including API-only tailnets created via the API. Paginated: returns at most `limit` results (Tailscale defaults to 100) plus a `cursor`. Pass that cursor back to fetch the next page; an empty cursor in the response means you have reached the end. Requires OAuth authentication.

输入参数limitcursororganization

tailscale_create_org_tailnet

Create organization tailnet

Create a new API-only tailnet in your organization. Returns the tailnet (id, displayName, orgId, dnsName, createdAt) AND a freshly-minted OAuth client for it. SECURITY: the response body contains that OAuth client's secret verbatim, and it cannot be retrieved again. MCP clients commonly persist tool responses to logs and conversation transcripts; treat this response as sensitive. Requires an OAuth client with the 'tailnets' scope -- an API key will not work. To then operate on the new tailnet, set TAILSCALE_OAUTH_TAILNET to its id and use an OAuth client with the 'all' scope. Organizations are limited to 10 tailnets including the original unless Tailscale sales has raised the limit. The response may include `alreadyExists: true`; Tailscale's spec ALSO documents a 400 for a name already in use and neither has been observed, so after a timeout call tailscale_list_org_tailnets before retrying rather than assuming either.

输入参数displayName必填organization

tailscale_delete_tailnet

Delete tailnet

Permanently delete a tailnet. This is IRREVERSIBLE and removes every device, user, ACL, and key in it. By default it acts on the tailnet the current credentials point at (TAILSCALE_TAILNET, or TAILSCALE_OAUTH_TAILNET when targeting an API-only tailnet). Pass `tailnet` to name a different one -- e.g. an id returned by tailscale_list_org_tailnets -- which requires credentials scoped to reach it; UNVERIFIED against a live tailnet, so expect a 403/404 if your token cannot. You must always pass `confirmTailnet` matching the effective target exactly; the call is refused locally otherwise. That check is a typo guard, not an authorization gate: when you also pass `tailnet` you are supplying both halves of the comparison, so it proves only that they agree -- it is a genuine second look only on the omit-`tailnet` path, where the value has to match the operator's environment. Restricting who may delete at all is TAILSCALE_READONLY / TAILSCALE_TOOLS, which drop this tool from the server entirely. Intended for tearing down API-only tailnets created by tailscale_create_org_tailnet.

输入参数tailnetconfirmTailnet必填

tailscale_list_webhooks

List webhooks

List all webhooks configured for your tailnet.

无需输入参数。

tailscale_get_webhook

Get webhook

Get details for a specific webhook.

输入参数webhookId必填

tailscale_create_webhook

Create webhook

Create a new webhook. The response includes the webhook's signing secret -- this is the only opportunity to capture it; save it immediately. Set providerType when the endpoint is a Slack, Mattermost, Google Chat or Discord incoming-webhook URL, so the events arrive in the format that provider renders. SECURITY: the response body contains the secret verbatim. MCP clients commonly persist tool responses to logs and conversation transcripts; treat this response as sensitive.

输入参数endpointUrl必填providerTypesubscriptions必填

tailscale_update_webhook

Update webhook

Update an existing webhook's endpoint URL and/or subscriptions.

输入参数webhookId必填endpointUrlsubscriptions

tailscale_delete_webhook

Delete webhook

Delete a webhook. This is irreversible -- the webhook secret cannot be recovered.

输入参数webhookId必填

tailscale_rotate_webhook_secret

Rotate webhook secret

Rotate a webhook's secret. Returns the new secret -- save it immediately, as it cannot be retrieved again. The old secret is immediately invalidated. SECURITY: the response body contains the secret verbatim. MCP clients commonly persist tool responses to logs and conversation transcripts; treat this response as sensitive.

输入参数webhookId必填

tailscale_test_webhook

Test webhook

Send a test event to a webhook endpoint to verify it is configured correctly and receiving events.

输入参数webhookId必填

tailscale_list_posture_integrations

List posture integrations

List all device posture integrations configured for your tailnet.

无需输入参数。

tailscale_get_posture_integration

Get posture integration

Get details for a specific device posture integration.

输入参数integrationId必填

tailscale_create_posture_integration

Create posture integration

Create a new device posture integration.

输入参数cloudIdclientIdprovider必填tenantIdclientSecret必填

tailscale_update_posture_integration

Update posture integration

Update an existing posture integration's credentials or configuration.

输入参数cloudIdclientIdtenantIdclientSecretintegrationId必填

tailscale_delete_posture_integration

Delete posture integration

Delete a posture integration. This is irreversible.

输入参数integrationId必填

tailscale_get_audit_log

Get audit log

Get the tailnet audit/configuration log. Shows who changed what and when -- useful for troubleshooting and compliance. Optional actor, target and event filters narrow the query server-side, so a targeted question doesn't have to pull the whole window.

输入参数endactoreventstart必填target

tailscale_get_network_flow_logs

Get network flow logs

Get network traffic flow logs showing connections between devices. Shows source/destination nodes, timestamps, and traffic metadata -- useful for security monitoring and debugging connectivity.

输入参数endstart必填

tailscale_list_device_invites

List device invites

List all device invites for a specific device.

输入参数deviceId必填

tailscale_create_device_invite

Create device invite

Create a device share invitation that allows an external user to access a specific device in your tailnet.

输入参数emaildeviceId必填multiUseallowExitNode

tailscale_get_device_invite

Get device invite

Get details for a specific device invite.

输入参数inviteId必填

tailscale_delete_device_invite

Delete device invite

Delete a device invite. This is irreversible -- the invite link will stop working.

输入参数inviteId必填

tailscale_accept_device_invite

Accept device invite

Accept a device share invitation using the invite URL or code.

输入参数invite必填

tailscale_list_user_invites

List user invites

List the open (not yet accepted) user invites for your tailnet. Accepted invites are not returned.

无需输入参数。

tailscale_create_user_invite

Create user invite

Create a new user invite that allows someone to join your tailnet.

输入参数roleemail

tailscale_get_user_invite

Get user invite

Get details for a specific user invite.

输入参数inviteId必填

tailscale_delete_user_invite

Delete user invite

Delete a user invite. This is irreversible -- the invite link will stop working.

输入参数inviteId必填

tailscale_resend_device_invite

Resend device invite

Resend a device invite email.

输入参数inviteId必填

tailscale_resend_user_invite

Resend user invite

Resend a user invite email.

输入参数inviteId必填

tailscale_list_services

List services

List all Tailscale Services in your tailnet. Services provide stable MagicDNS names and virtual IPs, decoupled from individual devices. Note: this MCP has no create-service tool. The API documents its Service PUT as create-or-update, but tailscale_update_service sends only the fields you pass, so do not use it to create one. Use the update/delete/approval tools here once the service exists.

无需输入参数。

tailscale_get_service

Get service

Get details for a specific Tailscale Service, including its MagicDNS name, virtual IP, and configuration.

输入参数serviceName必填

tailscale_update_service

Update service

Update a Tailscale Service's configuration.

输入参数tagsportsserviceName必填autoApproveHosts

tailscale_delete_service

Delete service

Delete a Tailscale Service. This is irreversible -- the service's MagicDNS name and virtual IP will be released.

输入参数serviceName必填

tailscale_list_service_hosts

List service hosts

List devices hosting a specific Tailscale Service.

输入参数serviceName必填

tailscale_get_service_device_approval

Get service device approval

Get the approval status of a specific device for a Tailscale Service.

输入参数deviceId必填serviceName必填

tailscale_set_service_device_approval

Set service device approval

Approve or reject a device to host a Tailscale Service.

输入参数approved必填deviceId必填serviceName必填

tailscale_list_log_stream_configs

List log stream configs

List all log streaming configurations for your tailnet. Fetches both 'configuration' (audit) and 'network' (flow) log stream configs. Log streaming sends logs to external destinations like Axiom, Datadog, Splunk, Elasticsearch, or S3.

无需输入参数。

tailscale_get_log_stream_config

Get log stream config

Get the log streaming configuration for a specific log type.

输入参数logType必填

tailscale_set_log_stream_config

Set log stream config

Set the log streaming configuration for a specific log type. Configures where logs are sent (e.g. Axiom, Datadog, Splunk, Elasticsearch, S3). Per-destination required fields: - splunk / elastic / panther / cribl / datadog / axiom: url + token (user optional) - s3: s3Bucket + s3Region + s3AuthenticationType, plus either (s3AccessKeyId + s3SecretAccessKey) for 'accesskey' auth or s3RoleArn for 'rolearn' auth. Call tailscale_create_aws_external_id first when using 'rolearn'.

输入参数urlusertokenlogType必填s3Buckets3Regions3RoleArns3KeyPrefixs3AccessKeyIddestinationType必填compressionFormats3SecretAccessKey另有 2 个

tailscale_delete_log_stream_config

Delete log stream config

Delete a log streaming configuration. Logs will stop being sent to the configured destination.

输入参数logType必填

tailscale_get_log_stream_status

Get log stream status

Get the status of log streaming for a specific log type. Shows whether logs are being delivered successfully.

输入参数logType必填

tailscale_create_aws_external_id

Create AWS external ID

Create or get the AWS external ID Tailscale presents when assuming your IAM role for S3 log streaming. Put it in the role trust policy's sts:ExternalId condition, then check it with tailscale_validate_aws_trust_policy.

输入参数reusable

tailscale_validate_aws_trust_policy

Validate AWS trust policy

Validate that an AWS IAM role trust policy is correctly configured with the Tailscale external ID. Use this after setting up the IAM role for S3 log streaming.

输入参数roleArn必填externalId必填

版本历史

10
  1. v0.23.4最新Nov 16, 2026
  2. v0.23.3Nov 16, 2026
  3. v0.23.2Nov 12, 2026
  4. v0.23.1Oct 31, 2026
  5. v0.23.0Oct 9, 2026
  6. v0.22.0Oct 9, 2026
  7. v0.21.2Oct 6, 2026
  8. v0.21.1Sep 30, 2026
  9. v0.21.0Sep 21, 2026
  10. v0.20.2Sep 16, 2026

评分

已满足适用检查项的 90%

该评分衡量此收录条目的完整程度,依据注册中心条目、端点与公开来源计算得出。它不是对服务器本身的评价,也不表示服务器安全或当前可用:可连通性是带日期的检查结果,评分也不包含安装量或用户评价。

  • 近 30 天内可连通25 分
  • 已声明认证方式10 分

    请在注册中心条目中声明凭据请求头,或保持端点能够响应探测,以便判定其认证方式。

  • 已列出工具必需15 分
  • 描述必需15 分
  • 图标10 分
  • 文档15 分
  • 许可证10 分