---
title: Dropzone Is Now Agent-Native - MCP Server, API, and llms.txt
date: 2026-11-16
description: AI agents can now create and open single-use, encrypted Dropzone links through an MCP server, a no-auth HTTP API, and machine-readable docs at /llms.txt.
tags:
  [
    "ai-agents",
    "mcp",
    "model-context-protocol",
    "llms-txt",
    "secrets-management",
    "dropzone",
    "developer-tools",
  ]
---

# Dropzone Is Now Agent-Native

More of the work that used to happen in a terminal now happens through an AI agent. Agents write code, open pull requests, deploy services, and set up environments. Sooner or later, that work runs into a credential: a database URL, an API key, a `.env` file someone needs to hand over.

Until now, there was no good way to do that. You pasted the secret into the chat, where it lived forever in a transcript. Or the agent printed a secret back to you, and now it sat in your terminal scrollback and maybe a log file too.

Today Dropzone works natively with agents. Agents get the same thing people do: **encrypted links that work once and then delete themselves.**

---

## What's new

### An MCP server

Dropzone now runs a [Model Context Protocol](https://modelcontextprotocol.io) server at `https://dropzone.sh/api/mcp`. It exposes two tools:

- **`create_drop`** encrypts text or a file and returns a single-use link.
- **`open_drop`** opens a Dropzone link and returns its contents. The drop is then permanently deleted.

In Claude Code, add it with one command:

```sh
claude mcp add --transport http dropzone https://dropzone.sh/api/mcp
```

Any client that supports remote (Streamable HTTP) MCP servers works the same way: Cursor, VS Code, Claude, and others. Setup snippets for each are on the [agents page](/agents).

The `open_drop` tool is marked as destructive in its MCP annotations, so well-behaved clients ask before running it. That matters: opening a link uses it up for everyone.

### A no-auth HTTP API

No account, API key, or SDK needed. If your agent can run `curl`, it can use Dropzone:

```sh
# create a drop
curl -s https://dropzone.sh/api/upload -F file=@.env

# open a drop (single use)
curl -s https://dropzone.sh/api/retrieve -H 'Content-Type: application/json' -d "{\"url\": \"$LINK\"}"
```

The upload endpoint accepts multipart forms, JSON, piped input, and raw bodies. The retrieve endpoint returns raw bytes with the correct content type, or JSON if you add `format=json`. Errors come back as structured JSON with stable codes like `not_found` and `invalid_key`, so agents can recover without guessing. The full spec is at [/openapi.json](/openapi.json).

### A CLI that encrypts locally

The hosted MCP server and the plaintext HTTP API are the easiest way in, but they encrypt on Dropzone's server. The key is never stored, but the server does see your data for the length of the request. When that matters, use the CLI. It's a single file with no dependencies that encrypts and decrypts on your machine, so only ciphertext ever reaches Dropzone:

```sh
curl -fsSO https://dropzone.sh/dropzone.mjs
node dropzone.mjs send .env
node dropzone.mjs open "$LINK"
```

This is the same end-to-end encryption the web app uses: the key is generated locally and only ever lives in the link, after the `#`.

### Docs written for machines

[/llms.txt](/llms.txt) explains Dropzone in a format language models read well. It covers the API, the MCP setup, and, most importantly, the rules: a link works once, don't open links meant for someone else, and save the contents if you'll need them again. [/llms-full.txt](/llms-full.txt) adds every blog post for agents that want more context.

### Links that are safe for agents to fetch

Every Dropzone share link (`/d/...`) now includes server-rendered instructions for agents. When an agent fetches the page without running JavaScript, it reads how to retrieve the contents through the API, and the drop stays intact. Agents only consume a link when they deliberately call the retrieve endpoint or `open_drop`.

---

## Why this matters

Agents are good at moving fast. But speed plus credentials is how secrets end up in chat logs, CI output, and model context windows that get stored, summarized, and shared.

Single-use links fix the core problem: **the secret exists in exactly one place, for exactly as long as it's needed.** An agent can hand you a freshly generated API key as a link instead of printing it. You can give an agent a `.env` file without pasting it into a transcript. Two agents can pass a credential between them without it sitting in task queues and logs.

One caveat: MCP tools pass values through the model, so `create_drop` and `open_drop` put the secret in the agent's context. When the agent has a shell, the CLI avoids that, because it reads from and writes to files directly.

We wrote more about this in [How AI Agents Should Handle Secrets](/blog/how-ai-agents-should-handle-secrets) and [Give Your Coding Agent a .env File Without Pasting It Into Chat](/blog/give-your-coding-agent-a-env-file).

---

## Get started

- **Humans:** keep using [dropzone.sh](/) exactly as before.
- **Agents:** point them at [dropzone.sh/llms.txt](/llms.txt), or add the MCP server.
- **Teams:** add one line to your `AGENTS.md` or `CLAUDE.md` telling agents to share secrets with Dropzone instead of plaintext. There's a ready-made snippet on the [agents page](/agents).

It's free, and there's nothing to sign up for.
