Skip to main content
Glama

@dropthis/mcp

Official MCP server for dropthis — publish content (HTML, files, or a URL to fetch) and get back a permanent public URL, from any MCP-compatible agent (Claude Code, Claude Desktop, Cursor, Windsurf, opencode, ChatGPT, n8n, …).

Two ways to connect:

  • Local (stdio) — npx @dropthis/mcp, authenticated with your sk_ API key. Best for coding agents.

  • Remote (hosted) — https://mcp.dropthis.app/mcp over Streamable HTTP, with OAuth for chat clients or a static sk_ Bearer for automation. Best for ChatGPT / claude.ai / n8n.

Local / stdio

Add to your MCP client config:

{
  "mcpServers": {
    "dropthis": {
      "command": "npx",
      "args": ["-y", "@dropthis/mcp"],
      "env": { "DROPTHIS_API_KEY": "sk_..." }
    }
  }
}

Get an API key from your dropthis account. The server reads DROPTHIS_API_KEY (and optional DROPTHIS_BASE_URL). Set DROPTHIS_READ_ONLY=true to register only the read tools — a safe way to give an agent read access to your drops with no write/delete risk. Set DROPTHIS_TOOLSETS (e.g. drops) to trim the tool surface to what a session needs (Toolsets). Claude Desktop users can install the one-click .mcpb bundle instead (the API key is stored in your OS keychain).

See docs/setup.md for per-client instructions (Claude Code, Cursor, Windsurf, VS Code, …).

Related MCP server: HTML Deploy MCP Server

Remote (hosted) connector

Point an MCP-capable client at the hosted endpoint:

https://mcp.dropthis.app/mcp

One-click install (the deep-link opens the editor and adds the remote server):

  • Cursor: Add to Cursor

  • VS Code: Add to VS Code

  • Chat clients (ChatGPT, claude.ai) authenticate via OAuth 2.1 — add the connector URL, sign in with a 6-digit email code (no password), then approve the consent screen, which shows the requested permissions and lets you pick the workspace to publish into.

  • Automation (n8n, CI, custom agents) sends a static Authorization: Bearer sk_... header and skips OAuth. See docs/n8n.md.

  • Read-only: append ?readonly=true to the endpoint (https://mcp.dropthis.app/mcp?readonly=true) to register only the read tools, even for a write-capable credential.

  • Manage or disconnect the connector later from the console's Connected apps page at https://app.dropthis.app.

Tools

Tool

Purpose

dropthis_publish

Publish new content (content | source_url | files | file/paths) → permanent URL

dropthis_update_content

Publish a new content version to an existing drop, keeping its URL

dropthis_update_settings

Update a drop's settings (title, visibility, password, noindex, expiry, metadata) and routing (move onto a custom domain / back to the shared pool, rename the vanity slug)

dropthis_get

Fetch one drop's metadata

dropthis_get_content

Read back what a drop is serving — its file manifest, or one file's content (the read half of the edit loop)

dropthis_resolve

Turn a drop's public URL or slug into its drop_… id (owner-scoped) — the recovery path for the id-based tools

dropthis_list

List your drops (paginated)

dropthis_list_deployments

List a drop's deployment (version) history

dropthis_restore_deployment

Roll a drop back to a prior deployment's content (Pro+ version history) — mints a new deployment copying it and makes it current, URL unchanged

dropthis_analytics

Read a drop's approximate view analytics (Keep+ for counts, Pro+ for country/referer/daily breakdowns)

dropthis_delete

Delete a drop (requires confirm: true)

dropthis_account

Authenticated account profile (id, email, status) including the account's limits for preflight sizing

dropthis_domains_connect

Connect a custom domain (path or dedicated mode) and get the CNAME record to create

dropthis_domains_verify

Re-check a domain's DNS/TLS and advance its status toward live

dropthis_domains_get

Read one domain's stored state and DNS instructions (no live DNS check)

dropthis_domains_list

List the account's custom domains and which is the default publish target

dropthis_domains_update

Repoint a dedicated domain to another drop, or set/clear the default path domain

dropthis_domains_delete

Disconnect a custom domain (requires confirm: true)

dropthis_workspaces

List the workspaces this connection can publish to, and which is active

dropthis_use_workspace

Switch the active workspace for this connection (persists server-side)

dropthis_create_workspace

Create a new team workspace (you become its owner)

dropthis_rename_workspace

Rename a team workspace or change its slug

dropthis_delete_workspace

Delete a team workspace (owner only; requires confirm: true)

dropthis_members

List a team workspace's members and their roles

dropthis_invite_member

Invite an email to a team workspace as admin or member

dropthis_update_member_role

Change a member's role (owner/admin/member)

dropthis_remove_member

Remove a member from a workspace, or leave it (requires confirm: true)

dropthis_invitations

List your own pending workspace invitations

dropthis_accept_invitation

Accept a workspace invitation and join (by token or invitation id) — the teammate join path

file/paths are local/stdio only — the hosted Worker omits them from the tool schemas entirely. dropthis_update_content accepts the same content inputs as dropthis_publish; a source_url is fetched server-side (SSRF-guarded) and stored as the new version. The id-based tools (dropthis_update_content, dropthis_update_settings, dropthis_get, dropthis_get_content, dropthis_analytics, dropthis_delete, dropthis_list_deployments, dropthis_restore_deployment) require the full drop_… id from the publish response and are strict id-only: pass a URL or slug and the tool returns an error pointing you at dropthis_resolve, which turns a public URL/slug back into the drop_… id (owner-scoped). Resolve once, then edit by id — persist the drop_… id, since URLs and slugs are locators that can drift. Connections whose OAuth grant lacks the drops:write scope see only the read tools.

dropthis_account returns your account's exact limits.

The team-management tools (dropthis_create_workspace, dropthis_rename_workspace, dropthis_delete_workspace, dropthis_members, dropthis_invite_member, dropthis_update_member_role, dropthis_remove_member, dropthis_invitations, dropthis_accept_invitation) need a team-scoped credential (ADR-0068) — a publish-only key cannot manage teams. Find a workspace id with dropthis_workspaces and a member's accountId with dropthis_members. dropthis_accept_invitation is the teammate's join path: list your invites with dropthis_invitations, then accept by its invitation id (or by the raw token from the invite email).

Workspaces (teams)

Every drop lands in a workspace (ADR-0067). A fresh login homes to your personal workspace; teams are shared workspaces with members and roles. Each connection has one active workspace, and publishes go there by default:

  • dropthis_workspaces lists the workspaces this connection can act in and flags the active one.

  • dropthis_use_workspace switches the active workspace; the choice persists server-side across reconnects.

  • dropthis_publish takes a per-call workspace override — write-side targeting for a new drop.

  • dropthis_list takes a per-call workspace selector — list another workspace you belong to without switching.

  • id-addressed ops (update_content, update_settings, delete, …) always act in the drop's own workspace (a drop never moves workspace).

  • dropthis_account echoes the active workspace (name, kind, your role).

A static sk_ API key is pinned to the one workspace it was minted in — dropthis_use_workspace and the per-call workspace override/selector do not apply to it. To act in another workspace with an sk_ key, mint a key in that workspace. OAuth (remote) connections are not pinned and can switch freely.

Permissions & read-only

Write tools (publish, update, delete, domain and team management) require write access; the read tools never do:

  • A static Authorization: Bearer sk_... key is always write-capable (account-scoped).

  • An OAuth (remote connector) grant must hold the drops:write scope to see the write tools. The read tools need no scope, so a grant without drops:write — or any session in read-only mode — sees the read tools alone. A 403 insufficient_scope from a write tool means re-authenticate to request drops:write.

There are two ways to force a read-only session even with a write-capable credential — only the read tools are registered, so there is zero write/delete risk:

  • Local / stdio: set the env var DROPTHIS_READ_ONLY=true.

  • Remote: append ?readonly=true to the endpoint (https://mcp.dropthis.app/mcp?readonly=true).

The read tools that stay available in a read-only session are: dropthis_get, dropthis_list, dropthis_list_deployments, dropthis_get_content, dropthis_analytics, dropthis_resolve, dropthis_account, dropthis_domains_list, dropthis_domains_get, dropthis_workspaces, dropthis_members, and dropthis_invitations. Everything else is a write tool and is hidden (dropthis_restore_deployment, a version-history rollback, needs the drops:write scope).

Toolsets (trim the tool surface)

All 29 tools load by default, but a publish-and-edit session rarely needs the 17 domains/workspaces/members/invitations tools. Register a subset to cut the per-session tool prose:

  • Local / stdio: set DROPTHIS_TOOLSETS to a comma list, e.g. DROPTHIS_TOOLSETS=drops.

  • Remote: append ?toolsets= to the endpoint (beside ?readonly=), e.g. https://mcp.dropthis.app/mcp?toolsets=drops or ?toolsets=drops,account.

Values: drops (the core publish/edit/read tools — 11), domains (6), workspaces (workspaces + members + invitations — 11), and account (1). Unset, empty, or all-unrecognized → all toolsets (the default). Unknown tokens are ignored. ?readonly= and ?toolsets= compose: each hides tools independently, so ?toolsets=drops&readonly=true leaves only the drop read tools. The tool list is fixed at connect — restart the stdio server (or reconnect the remote connector) after changing the value. A hosted claude.ai connector has no query-param UI, so set it in the connector URL you add.

Multi-file bundles (files input)

A files bundle holds up to 200 files. Each file has a path (bundle-relative, used verbatim in HTML/CSS src/href attributes) and exactly one content source:

Field

Use for

Notes

content

UTF-8 text: HTML, CSS, JS, JSON, SVG, markdown

Text is sent inline

source_url

Remote assets: images, video, PDFs, fonts

Server fetches the URL; no bytes pass through your agent. Optional content_type, size_bytes, checksum_sha256, transform

content_base64

Small inline binary blobs only

Capped at 64 KiB encoded; rejected with a corrective error above that threshold pointing at source_url

Never base64-encode an image that is already publicly reachable — use source_url instead. Example bundle with mixed sources:

{
  "files": [
    { "path": "index.html", "content": "<html>…<img src='hero.jpg'>…</html>" },
    { "path": "hero.jpg", "source_url": "https://cdn.example.com/hero.jpg" },
    { "path": "logo.png", "source_url": "https://cdn.example.com/logo.png", "content_type": "image/png" }
  ]
}

Image transforms. A source_url image can carry a transform so the server resizes/re-encodes it on ingest — point at a big original and store a small web-optimised derivative, no scratch bucket needed. Fits inside the box, never upscales, strips metadata. Only with source_url; omit size_bytes/checksum_sha256 (the stored object reflects the output).

{
  "files": [
    { "path": "hero.jpg", "source_url": "https://cdn.example.com/original.png", "transform": { "width": 1080, "quality": 78, "format": "jpeg" } }
  ]
}

Editing a bundle — update_content is a partial update

dropthis_update_content patches by default (mode: "patch"). The files you send are upserted by path; every file you don't mention is carried forward unchanged. So to fix one page, send only that page — a previously-bundled image stays put:

{
  "drop_id": "drop_…",
  "files": [{ "path": "index.html", "content": "<html>…edited…</html>" }]
}

To remove a file, list its path in delete_paths:

{
  "drop_id": "drop_…",
  "files": [{ "path": "index.html", "content": "<html>…</html>" }],
  "delete_paths": ["assets/old-hero.jpg"]
}

To swap the entire content set in one call, use mode: "replace" — the files you send become the whole drop and everything else is dropped (delete_paths is invalid in replace mode).

Example prompts

Natural-language asks that exercise the main tools (the agent picks the tool):

  • Publish — "Publish this HTML report and give me the link." → dropthis_publish returns a permanent url and the drop_… id.

  • Self-contained bundle — "Publish this landing page with its four images" (HTML + files[] where each image is a source_url). → one drop, images fetched server-side and stored, no hot-linking.

  • Edit in place — "Change the headline on that drop." → dropthis_get_content reads the current file, you edit it, dropthis_update_content ships a new version at the same URL.

  • Recover the id — "Update https://abc123.dropthis.app/." → dropthis_resolve turns the URL into its drop_… id, then dropthis_update_content.

  • Custom domain — "Serve my drops at reports.example.com." → dropthis_domains_connect (path mode) returns the CNAME, then dropthis_domains_verify until live.

Privacy

dropthis is a hosted service: content you publish is sent to and stored by dropthis and served at a public URL. See the privacy policy at https://dropthis.app/privacy and the terms at https://dropthis.app/terms.

Support

Known limitations

  • Plan caps apply per drop and per account (size, TTL, custom domains, passwords) across the Free / Keep / Pro / Business tiers — call dropthis_account to read the active limits before a large publish.

  • Binary bytes can't ride in a tool call: inline content_base64 is capped at 64 KiB. For images/video/PDFs/fonts use source_url (the server fetches a public URL), or, on the local stdio server only, file/paths.

  • source_url must be publicly reachable over http(s); the server fetches it (SSRF-guarded). A private/localhost URL won't resolve.

  • id-only edits: the URL slug is not an id — keep the drop_… id from publish (or recover it with dropthis_resolve).

  • Setting a password is Pro-only; clearing one (null) is always allowed.

Develop

npm install
npm run dev          # tsx src/bin.ts (needs DROPTHIS_API_KEY)
npm run dev:worker   # wrangler dev (remote Worker)
npm test             # vitest (node) + vitest-pool-workers
npm run typecheck    # tsc (node + worker tsconfigs)
npm run lint         # biome
npm run build        # tsup → dist/bin.cjs (the npm package)
npm run build:worker # wrangler deploy --dry-run (bundle check)

One TypeScript codebase, two outputs: the stdio npm package and the Cloudflare Worker. Both are thin clients over the dropthis REST API (@dropthis/node for stdio, @dropthis/node/edge for the Worker); tool handlers are unit-tested against an injected fake client.

License

MIT

Available Tools

29 tools
dropthis_accept_invitationAccept an invitationAInspect

Accept a team-workspace invitation and join — this is the teammate's join path. Pass token (the raw single-use token from the invite email) OR invitation_id (from dropthis_invitations; the agent path, no email needed) — at least one is required, token wins if both are given. Requires a team-scoped credential (ADR-0068: members:write) authenticated as the invited email. Joins and switches your active workspace to the team; returns the joined workspace.

Inputs: token, invitation_id. Returns: id, kind, name, plan, +4 more

dropthis_accountGet account profileA
Read-only
Inspect

Return the authenticated account profile (id, email, display name, plan, status) WITH the active plan's entitlements — the full capability matrix (what's unlocked + the plan that unlocks each gated feature) plus numeric limits (max drop size, default drop lifetime/TTL, storage cap, custom-hostname + seat caps) — so a feature gate can be pre-checked and a publish sized upfront with no separate lookup. Also returns the active workspace (name, kind, your role) — call before a multi-team publish to confirm which workspace will receive it.

Inputs: no named parameters. Returns: id, plan, email, usage, +6 more

dropthis_analyticsGet a drop's view analyticsA
Read-only
Inspect

Approximate view analytics for one drop, by its drop_… id. Gated by the analytics capability: Free returns feature_not_in_plan (403, needs Keep); Keep (view_count) returns views + truncated only; Pro+ (full) also returns byCountry / byReferer / daily. Counts are best-effort — captured fire-and-forget at the edge, so treat them as an approximate signal, not exact human visits. Requires drop_id (id-only — for a public URL or slug call dropthis_resolve first). Use when the user asks how many views / how much traffic a drop got.

Inputs: drop_id (required). Returns: daily, views, byCountry, byReferer, +1 more

dropthis_create_workspaceCreate a team workspaceAInspect

Create a new team workspace (you become its owner). Requires a team-scoped credential (ADR-0068: workspaces:write) — a publish-only key cannot create teams. Returns the new workspace's id and slug; switching the active workspace to it is separate (dropthis_use_workspace). Use dropthis_workspaces to see the teams you already belong to. If creatorCanReach comes back false, the credential created the team outside its allowlist and will be denied on the next write — re-authenticate to obtain a credential that reaches it.

Inputs: name (required), slug. Returns: id, kind, name, plan, +4 more

dropthis_deleteDelete a dropA
Destructive
Inspect

Permanently delete a drop and its public URL by drop_id (the drop_… id, not the slug or URL). Destructive and irreversible; requires confirm: true.

Inputs: confirm (required), drop_id (required). Returns: dropId, deleted

dropthis_delete_workspaceDelete a team workspaceA
Destructive
Inspect

Permanently delete a team workspace by its id. Destructive and irreversible (its drops and members go with it); requires confirm: true. Owner only — requires a team-scoped credential (ADR-0068: workspaces:admin). Use dropthis_workspaces to find the workspace id.

Inputs: confirm (required), workspace (required). Returns: deleted, workspace

dropthis_domains_connectConnect a custom domainA
Idempotent
Inspect

Connect a custom domain (the user's own hostname) to the dropthis account and start the DNS loop. The response carries the exact CNAME record to create (dns[]: name → value) plus structured next hints: if you have access to the user's DNS provider tooling (e.g. a Cloudflare or registrar MCP), create the CNAME record yourself, then call dropthis_domains_verify; otherwise show the user the record and wait for them to create it. Re-call dropthis_domains_verify until status is live; then publish with domain set — or rely on the account default for path domains. Mode (immutable; delete and reconnect to change it): path = many drops under one hostname at https://{hostname}/{slug}/ — the first live path domain auto-becomes the account's default publish target; dedicated = the whole hostname serves exactly one drop at its root. Idempotent: re-connecting an already-connected hostname returns the existing domain.

Inputs: mode (required), hostname (required). Returns: id, dns, mode, next, +8 more

dropthis_domains_deleteDelete a custom domainA
Destructive
Inspect

Disconnect a custom domain: the hostname stops serving drops and its routes are removed (the drops themselves are NOT deleted). Destructive; requires confirm: true. Afterwards, remove your DNS record for the hostname — while your CNAME still points at dropthis, the hostname could be re-connected by another dropthis account (the response repeats this dangling-CNAME warning with the exact record). If the domain was the publish default, new publishes revert to the shared pool.

Inputs: domain (required), confirm (required). Returns: id, deleted, warning, hostname

dropthis_domains_getGet a custom domainA
Read-onlyIdempotent
Inspect

Fetch one custom domain's STORED state by its dom_… id or hostname: status (pending_dns/verifying/live/failed), mode, default flag, the DNS record to create (dns[] with name → value and the stored diagnostic hints), and next-step guidance. Reads what dropthis last recorded — it does NOT run a live DNS check; to re-check DNS/TLS and advance the status, call dropthis_domains_verify. Use to re-read the CNAME instructions for a connected domain, or to check a domain's state on a read-only connection. For one row per domain across the account use dropthis_domains_list.

Inputs: domain (required). Returns: id, dns, mode, next, +8 more

dropthis_domains_listList custom domainsA
Read-only
Inspect

List the account's custom domains: each row carries the dom_… id, hostname, mode (path/dedicated), status (pending_dns/verifying/live/failed), whether it is the account's default publish target, and the mounted drop_… id for dedicated domains. Use to check which domain publish lands on by default, or to find a hostname to pass as domain to dropthis_publish. Also pass a hostname as domain to dropthis_list to see the drops currently mounted on it.

Inputs: no named parameters. Returns: domains

dropthis_domains_updateUpdate a custom domainA
Idempotent
Inspect

Repoint a DEDICATED custom domain to a different drop (drop_id), or set/clear a PATH domain as the account's default publish target (default). Changes ROUTING only — to change the CONTENT of the page a domain serves, use dropthis_update_content on the drop, NOT this tool. Mode is immutable: delete and reconnect to change it. Takes the dom_… id or the hostname.

Inputs: domain (required), default, drop_id. Returns: id, dns, mode, next, +8 more

dropthis_domains_verifyVerify a custom domainA
Idempotent
Inspect

Check a custom domain's DNS and TLS provisioning and advance its status (pending_dns → verifying → live). Not blocking — if status comes back verifying or pending_dns, re-call after the retry_after seconds shown in the dns records; each record's diagnostics show the expected value vs what DNS currently observed. Always re-callable — also the recovery path after a failed status (e.g. a restrictive CAA record blocking certificate issuance). Once status is live the domain serves drops: publish with domain set, or rely on the account default for path-mode domains. Takes the dom_… id or the hostname.

Inputs: domain (required). Returns: id, dns, mode, next, +8 more

dropthis_getGet a dropA
Read-only
Inspect

Read back an EXISTING drop's settings and metadata — the settings read half of the edit loop: in a read-modify-write / read-before-patch cycle, read current settings here, change them, then write with dropthis_update_settings (content goes through dropthis_update_content). Fetch one drop by its drop_… id (id-only), returning its URL, slug, title, status, visibility, revisions, expiry, noindex flag, whether it is password-protected, custom metadata, and the current revision number. For a public URL or slug, call dropthis_resolve first to get the drop_… id. Settings and metadata only — for the bytes the drop actually serves use its read sibling dropthis_get_content (the two read halves: dropthis_get = settings/metadata, dropthis_get_content = served content).

Inputs: drop_id (required). Returns: id, url, next, slug, +11 more

dropthis_get_contentRead a drop's contentA
Read-only
Inspect

Read back the content an EXISTING drop is serving — the content read half of the edit loop: in a read-modify-write / read-before-patch cycle, read with this tool, modify, then ship the new version with dropthis_update_content. Requires drop_id (the drop_… id, id-only; for a public URL or slug call dropthis_resolve first to get the id). By default returns the CURRENT deployment's file manifest (entry plus each file's path, MIME type, and size in bytes); pass deployment_id (from dropthis_list_deployments) to read a historical version — to actually roll a drop back to a prior version, use dropthis_restore_deployment (this tool only reads) — or path (one of the manifest's files[].path values) to fetch one file: text content is returned directly — in the result text and, when it fits, mirrored into structuredContent.content (a file past ~80,000 characters comes back one window at a time, truncated with truncated: true and the next start_char offset — page through the whole file with start_char; never edit a partial window); binary files as a byte-count summary. Use when the user wants to read, view, inspect, diff, or edit what a drop currently serves. NOT for fetching arbitrary web pages (publish with source_url does that), and it returns content only — for a drop's settings/metadata use its read sibling dropthis_get (the two read halves: dropthis_get_content = served content, dropthis_get = settings/metadata).

Inputs: drop_id (required), path, start_char, deployment_id. Returns: next, path, entry, files, +12 more

dropthis_invitationsList my invitationsA
Read-only
Inspect

List the workspaces you have been invited to (your own pending invitations) — each row carries the invitation id, the workspace it is for, the role you would join as, its status, and when it expires. Requires a team-scoped credential (ADR-0068: members:read). Accept one with dropthis_accept_invitation (by invitation_id here, or by the raw token from the invite email).

Inputs: no named parameters. Returns: invitations

dropthis_invite_memberInvite a workspace memberAInspect

Invite an email to a team workspace as admin or member (owner is transferred, never invited). Requires a team-scoped credential (ADR-0068: members:write; owner/admin). role defaults to member. Returns the pending invitation; the invitee accepts it via dropthis_accept_invitation (their own agent/connection). Use dropthis_workspaces to find the workspace id.

Inputs: email (required), workspace (required), role. Returns: id, role, email, status, +4 more

dropthis_listList dropsA
Read-only
Inspect

List the account's drops newest first, paginated, returning each drop's drop_… id, URL, title, status, and expiry when available. Use when the user wants to list / show my drops / see what they have published. Each row's id is the drop_ id the mutating tools (update_content, update_settings, delete) need — not the slug or URL. Pass domain to only list drops mounted on that custom domain (see dropthis_domains_list for the account's domains). Pass workspace (a workspace id or slug from dropthis_workspaces) to list a workspace you belong to instead of your active one, without switching it (delegated credentials only).

Inputs: limit, cursor, domain, workspace. Returns: items, nextCursor

dropthis_list_deploymentsList a drop's deploymentsA
Read-only
Inspect

List a drop's content history — its past versions / revisions / deployments, newest first. Use when the user asks for the content history, previous versions, or revisions of a drop. Requires drop_id (the drop_… id, not the slug or URL).

Inputs: drop_id (required), limit, cursor. Returns: items, nextCursor

dropthis_membersList workspace membersA
Read-only
Inspect

List a team workspace's members by its id — each row carries accountId, email, role (owner/admin/member), whether it is you (isYou), and when they joined. Requires a team-scoped credential (ADR-0068: members:read). Use dropthis_workspaces to find the workspace id; the accountId here is what dropthis_update_member_role and dropthis_remove_member take.

Inputs: workspace (required). Returns: members

dropthis_publishPublish contentAInspect

Publish content to a NEW permanent public URL and get back its drop_… id. Accepts exactly one content input: content (inline HTML/text), files (in-memory multi-file bundle), file/paths (a local file or directory, stdio/local only), or source_url (a public http(s) URL the server fetches). For a files bundle: a drop holds up to 200 files; each file is content (text you write), source_url (a remote asset dropthis fetches server-side — use this for images/video/pdf/fonts), or content_base64 (small inline bytes only); never base64-inline an image into HTML. Use when the user wants to publish, share, post, put online, make public, or get a shareable link for generated content — a report, dashboard, slide deck, site, or file. Creates a NEW drop every call: do NOT call this to change something you already published — that makes a duplicate. To change an existing drop, use dropthis_update_content (the files at the URL) or dropthis_update_settings (title, visibility, password, expiry, metadata) with the drop_… id from this call's response. If you only kept the URL or slug, call dropthis_resolve to recover the drop_… id instead of publishing again (which would make a duplicate). Two URLs come back: url is the canonical, always-branded human view (the badge is guaranteed, with no client detection); for a single non-HTML file the response also carries raw_url, which serves that file's exact bytes at its natural path — share url with humans, hand raw_url to other agents (raw_url is null for HTML drops, where the page is the artifact, and for collections, whose per-file paths come from dropthis_get_content). Routing: by default the drop lands on the account's default custom domain when one is live (the first live path-mode domain becomes the default automatically), otherwise on the shared dropthis pool — accounts holding only dedicated domains also land on the shared pool. Pass domain (a LIVE custom domain — see dropthis_domains_list) to target a specific domain, plus an optional vanity slug on path-mode domains (1-63 lowercase letters/digits/hyphens; a taken slug is auto-suffixed with a warning). Don't pass domain for quick throwaway shares — default routing already handles those. Oversized png/jpeg/webp images are optimized server-side by default (re-encoded smaller, paths unchanged, every transform disclosed in the response warnings[] as image_optimized/image_optimize_skipped); pass optimize:false for byte-exact storage.

Inputs: file, path, slug, entry, +15 more. Returns: id, url, next, slug, +11 more

dropthis_remove_memberRemove a workspace memberA
Destructive
Inspect

Remove a member from a team workspace by the workspace id and the member's accountId (from dropthis_members), or leave the workspace by passing your own accountId. Destructive; requires confirm: true. Removing others requires a team-scoped credential (ADR-0068: members:admin); leaving needs members:write.

Inputs: confirm (required), workspace (required), account_id (required). Returns: removed, accountId, workspace

dropthis_rename_workspaceRename a team workspaceA
Idempotent
Inspect

Rename a team workspace or change its slug, by its workspace id. Requires a team-scoped credential (ADR-0068: workspaces:write; owner/admin). Pass name and/or slug — at least one is required. Use dropthis_workspaces to find the workspace id.

Inputs: workspace (required), name, slug. Returns: id, kind, name, plan, +4 more

dropthis_resolveResolve a URL/slug to a dropA
Read-only
Inspect

Turn a drop's public URL or slug — what a user typically pastes — into the drop itself, including its drop_… id. Owner-scoped: it only matches drops on THIS account, and returns no match for an unknown or foreign URL. The locator path for the editing tools, which require the drop_… id: resolve here, then call dropthis_update_content / dropthis_update_settings / dropthis_delete with the returned id. Accepts a drop_… id too (it passes straight through). Persist the drop_… id — URLs and slugs are locators, not identifiers, and can drift (a vanity slug is renameable, the shared pool host rotates), while the id never moves.

Inputs: target (required). Returns: id, url, next, slug, +11 more

dropthis_restore_deploymentRestore a prior deploymentAInspect

Roll a drop back to a prior deployment's content — the first-class version-history rollback (Pro+). Mints a NEW deployment whose content is copied from the chosen prior deployment (a dep_… id from dropthis_list_deployments) and makes it current; the drop's URL and settings are unchanged — only the content is restored. Restoring the deployment that is already current is a no-op. This IS the rollback path — prefer it over reading an old version with dropthis_get_content and re-publishing the files by hand. Below Pro the server returns feature_not_in_plan (403) with an upgrade_url. Requires drop_id (the drop_… id, id-only — for a public URL or slug call dropthis_resolve first) and deployment_id. Returns the updated parent drop (its unchanged URL + bumped revision).

Inputs: drop_id (required), deployment_id (required). Returns: id, url, next, slug, +11 more

dropthis_update_contentUpdate a drop's contentAInspect

Update the content of an EXISTING drop, keeping its current URL (ships a new deployment). Requires drop_id (the drop_… id from publish — id-only; call dropthis_resolve to convert a URL/slug) and exactly one content input (content, files, file, paths, or source_url). Use when the user edited, changed, regenerated, or wants to update the page and the URL should stay the same. PARTIAL BY DEFAULT (mode:"patch"): the files you send are upserted by path and every file you do NOT mention is carried forward unchanged — so to fix one page send only that page (a previously-bundled image stays), and to remove a file pass its path in delete_paths (e.g. delete_paths:["assets/old.png"]). Use mode:"replace" only to swap the ENTIRE content set in one call (the files you send become the whole drop and everything else is dropped; delete_paths is invalid in replace mode). Ships content only — it never changes settings; for title/visibility/password/expiry/metadata use dropthis_update_settings, and to create a brand-new drop use dropthis_publish. Not idempotent: a retry creates another deployment unless you pass the same idempotency_key. Oversized png/jpeg/webp images in the new content are optimized server-side by default (re-encoded smaller, paths unchanged, every transform disclosed in the response warnings[] as image_optimized/image_optimize_skipped); pass optimize:false for byte-exact storage.

Inputs: drop_id (required), file, mode, path, +10 more. Returns: id, url, next, slug, +11 more

dropthis_update_member_roleChange a member's roleA
Idempotent
Inspect

Change a workspace member's role to owner, admin, or member, by the workspace id and the member's accountId (from dropthis_members). Requires a team-scoped credential (ADR-0068: members:admin); only an owner may touch an owner, enforced server-side. Setting role=owner TRANSFERS ownership of the workspace to that member — a high-impact handoff that requires confirm: true.

Inputs: role (required), workspace (required), account_id (required), confirm. Returns: role, email, isYou, joinedAt, +1 more

dropthis_update_settingsUpdate a drop's settingsA
Idempotent
Inspect

Change an EXISTING drop's settings — title, visibility (public/unlisted), password, noindex, expiry, metadata, or its routing (move onto a custom domain / back to the shared pool, and rename its vanity slug) — by its drop_… id (id-only). Does not touch the content at the URL: to replace content use dropthis_update_content; to create a new drop use dropthis_publish. For a public URL or slug, call dropthis_resolve first to get the drop_… id. Idempotent — applying the same values again is a no-op.

Inputs: drop_id (required), slug, title, domain, +5 more. Returns: id, url, next, slug, +11 more

dropthis_use_workspaceSwitch workspaceA
Idempotent
Inspect

Switch the active team/workspace for this connection. Subsequent publishes land in it; the choice persists server-side across reconnects. Use dropthis_workspaces to list available workspaces first.

Inputs: workspace (required). Returns: id, kind, name, role, +2 more

dropthis_workspacesList workspacesA
Read-only
Inspect

List the workspaces (teams) this connection can act in, with the currently active one flagged (isActive). dropthis_account shows the active workspace on the current session. (Write-enabled connections can change the active workspace with dropthis_use_workspace.) If you need to publish into a workspace that is NOT currently active, call dropthis_use_workspace with its slug first (or pass workspace to dropthis_publish).

Inputs: no named parameters. Returns: active, workspaces

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 29 tools

    Disambiguation5/5

    Each tool targets a distinct resource and action, with no overlapping purposes. The read siblings dropthis_get and dropthis_get_content are explicitly differentiated as settings vs served content, and publish/update/delete/restore are clearly separated.

    Naming Consistency3/5

    All tools share the dropthis_ prefix, but the verb/noun ordering varies: drops use bare verbs (publish, get, list, delete), content uses verb_noun (update_content, get_content), and domains use noun_verb (domains_connect, domains_verify). This mix is readable but not fully consistent.

    Tool Count3/5

    29 tools is heavy, but the scope spans five sub-domains (drops, deployments, domains, workspaces, members/invitations). Each tool has a distinct role, so the count is justifiably high, though it exceeds the typical comfortable range of 3-15.

    Completeness4/5

    The drop lifecycle (create/read/update/delete, versioning/rollback, analytics) and domain management are complete, and workspaces/members/invitations cover team collaboration. Minor gaps include no way to decline or revoke invitations and no raw_url retrieval for existing drops.

    Maintenance

    ActivityNo data
    ResponsivenessSyncing

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      MCP server for BrewPage, a free no-signup hosting service. Lets AI agents publish HTML, Markdown, JSON, files, or a full multi-file static site and get a public URL instantly via a REST API.
      25
      5
      Apache 2.0
    • A
      license
      A
      quality
      D
      maintenance
      Lets MCP clients publish a single file to a permanent, shareable link via whamlink. Supports tools for managing links, including registration, publishing, listing, updating access, replacing content, and deleting links.
      6
      28 npm
      MIT