How to Share a Claude Design With a Client Securely (2026)

Last updated: July 2026

Quick answer: Claude Design builds the prototype, mockup, or one-pager in minutes — but the share decides who controls it. Its native sharing is a public link (org-internal view/comment/edit links, plus a public URL carrying an auth token that anyone who gets it keeps), with no NDA gate, no per-viewer watermark, and no viewer analytics — perfect for public work, wrong for a confidential client deliverable. The fix is to export the design (standalone HTML for an interactive prototype, or PDF/image for a static one-pager) and send it like a deliverable: NDA-gated, per-viewer watermarked, version-tracked, revocable, and analytics-instrumented. On Peony, the exported .html renders live with its JavaScript executing inside that control layer — at the Data Room tier ($52/admin/month), not Enterprise. The frame for the whole post: a public link is a portfolio; a controlled link is a deliverable.

I'm Deqian Jia, co-founder of Peony, a data room company serving 5,900+ customers. I spend most of my time on how files actually render and move between two parties, and since Anthropic launched Claude Design in April 2026, a new kind of file has started landing in client work: the design itself. A product designer ships a prototype, a founder "vibe-codes" an investor mockup, an agency hands a client a brand one-pager — built conversationally in Claude Design in an afternoon — and then they hit the wall this whole post is about: how do I send the design to a client without either flattening it or losing control of it?

Here's the thesis, and it's deliberately narrow: Claude Design makes the work in minutes; the share decides who controls it. A native publish link is a portfolio — anyone with the URL opens it, it can be indexed, you can't watermark it, recall it, or see who looked. The moment a Claude Design becomes a client deliverable — an unreleased product UI, a brand system, a pitch one-pager, an investor prototype — you need to share it like a deliverable: NDA-gated, per-viewer watermarked, version-tracked, revocable, and instrumented. A portfolio is built to be seen by anyone; a deliverable is built to be controlled. The rest of this post is how you make that switch, and it's written to be useful even if you never touch Peony — I'll be explicit about where the free public link beats us.

What this post is — and what it is not. This is specifically about sharing the outputs of the Claude Design product (the April-2026 prototypes, mockups, decks, and one-pagers) in the designer-to-client review workflow. If you want the general version — securely sharing any Claude HTML artifact (an app, a doc, a model), not specifically a design — that's how to securely share a Claude artifact. If you're trying to pick a tool rather than learn the workflow, see our head-to-head, best tools to share a Claude artifact securely. And if your artifact is a different type — a live dashboard, a board report, or a financial model — those have their own playbooks (dashboard, board report, financial model). This one owns the design / prototype / one-pager asset and the designer → client persona. One thing I won't pretend to do: Peony doesn't make designs — it's not a design tool. It's the confidential share-and-track layer that goes around the design after Claude builds it.

---

What does "sharing" a Claude Design actually involve — and where does it leak?

Sharing a Claude Design means getting the prototype, mockup, or one-pager out of Claude Design and in front of someone who can react to it — and the leak is hiding in how you get it out. Claude Design gives you a few native paths, and they were built for internal collaboration or public showcasing, not for a confidential client deliverable:

• Org-internal links — view, comment, or edit links scoped to your Anthropic organization. Great for a teammate; useless for an external client, who isn't in your org and can't open them.
• A public share URL — a link carrying an embedded auth token. Anyone with the URL opens the design in a browser without logging in, and (this is the part people miss) once the URL is out, anyone who has it keeps access. Treat it as fully public even if you sent it to one person.
• Export — standalone HTML, PDF, PPTX, ZIP, or send to Canva, plus a handoff bundle to Claude Code for the engineers. This is the path most designers use to reach a client, because it's the only one that doesn't require the client to be on Claude.
• Handoff to Claude Code — the build path, for turning the design into real code, not the client-review path.

The failure mode is almost always the same: to reach an external client, you export to standalone HTML and paste it onto a random public host — and the moment you do, you've converted a confidential design into an ungoverned bearer link. It's live and interactive, which feels like a win, but it has no watermark, no NDA, no tracking, and no off switch. That is exactly the gap this post closes: keep the export, lose the ungoverned link.

Why isn't the native Claude Design share link enough for a client deliverable?

Because the native link optimizes for frictionless showing, and a client deliverable needs control — and those are different jobs. The public share URL is a bearer link: possession is access. For a portfolio piece that's a feature; for an unreleased product UI it's the whole problem. You can't tell who saw it, you can't tie a leaked screenshot to a person, you can't gate it behind an NDA, and you can't pull it back when the design changes or the engagement ends. The link just sits out there, live and ungoverned, indefinitely.

This is the spine of the post: a public link is a portfolio; a controlled link is a deliverable. Most designers, faced with "how do I share this safely," reach for whichever link is closest — the native publish URL, because it's right there in Claude Design. That instinct is fine for public work and exactly backwards for confidential work. You don't make an unreleased design safer by publishing it faster; you make it leakier. The switch is to keep the design exactly as interactive as Claude built it and put a control layer around the render. Share publicly when the value survives being public — a marketing mockup, a conference concept, a portfolio shot can all be public freely. A client deliverable — an unreleased UI, a brand system, an investor prototype — has to be shared under control.

How do I share a Claude Design privately — without a public link?

Bind the view to a named client instead of to an anonymous URL. That single move is what turns a portfolio link into a deliverable. Instead of publishing the design to a public URL, export it and host it behind an identified, tracked link — often an NDA acknowledgement first — so each open ties to a specific person, every view is attributable, and you can revoke it later. You keep the interactivity of a live link and gain the control of a private channel, which most people assume you can't have at once.

Concretely, the private workflow looks like this:

1. In Claude Design, export the prototype to standalone HTML (or PDF/image if it's a static one-pager).
2. Upload it to a viewer that renders the HTML live instead of flattening it — so the client gets the working prototype, not a screenshot of it.
3. Turn on a dynamic per-viewer watermark so each viewer's identity is stamped across the design.
4. If the design is unreleased, put an NDA gate in front of it.
5. Send one tracked link per stakeholder, and set it to expire when the review window closes.

That's "private" in the sense a deliverable means it: not just unguessable, but identified, watermarked, tracked, and revocable. On Peony, that whole sequence is the default way you'd share a design with a client.

Public link vs. controlled link: which one is your Claude Design?

The honest answer is it depends entirely on whether the design is confidential — so here's the side-by-side that decides it. This is the signature comparison of the post: the native public/publish link (Anthropic's, or any paste-onto-a-host approach) versus a controlled link (the design exported into a data room like Peony). One is a portfolio; one is a deliverable.

Read this row by row and the decision makes itself. If every cell on the right is something you don't need, the native public link is the faster call — I mean that. If even three of them matter — and for an unreleased UI, a brand system, or an investor prototype they almost always do — you're sharing a deliverable, and you need the controlled column. For a fuller vendor-by-vendor view of which tools even render HTML live versus flatten it, we keep a ranked guide to which data rooms support HTML display; this post is the design-specific how-to that sits on top of it.

How do you keep the Claude Design interactive for the client AND keep control of it?

Use a viewer that renders the exported HTML live — executing the JavaScript in the client's browser — and that wraps per-viewer control around that same render. This is the capability that decides whether your prototype survives the trip. Peony renders .html/.htm natively with the JavaScript actually executing, so a Claude Design prototype runs for your client exactly as it ran for you: the client clicks through screens, triggers states, and uses the interactions you designed — it is not flattened to a PDF or an image. Most channels do the opposite (email attachments, many data rooms, plenty of file hosts) — they reject HTML or convert it to a static document, and the prototype dies in the conversion.

What makes the live render useful rather than just clever is the control layer traveling on it. The same prototype that's running for your client is simultaneously carrying a per-viewer dynamic watermark, sitting behind an optional NDA gate, generating page-level analytics, respecting redaction on anything not ready to show, and one click from instant revoke. The live design and the control aren't two things you bolt together — the control rides on the running render. That's the part the native public link can't do: it gives you the live prototype or nothing, never the prototype plus the per-viewer control.

Is a shared Claude Design trackable — can you see who actually viewed the prototype?

Not natively — the public Claude Design link is anonymous by construction, so the only way to know who looked is to share through a tracked link and read the analytics. A single public URL tells you nothing: ten stakeholders can open it and you learn nothing about any of them. One tracked link per stakeholder flips that, so every open is tied to a named person, with page-level analytics showing whether they opened the prototype, when, how long they stayed, and which screens they lingered on.

For a designer that's real signal, not a vanity metric. The client lead who reopened the checkout-flow screen four times before the review is reacting differently from the stakeholder who never clicked the link you sent last week — and you want to know which is which before you walk into the critique. It also quietly answers the awkward "did you get a chance to look at it?" question without you having to ask. Pair the analytics with per-viewer watermarks and one prototype becomes several accountable, measurable conversations instead of one link you fired into the dark.

How do you watermark a Claude Design so a leaked screen points back at whoever leaked it?

Turn on a per-viewer dynamic watermark — one that burns the specific viewer's name, email, and a timestamp across the live render, not a static logo pasted in a corner. Because each client-side viewer sees their own identity stamped over the design while they click through it, any screenshot or phone photo of an unreleased screen carries that identity with it. A leaked image of your unannounced UI points straight back at the person who leaked it.

Be precise about what this does and doesn't do, because overstating it would be dishonest: no tool can stop a person from photographing their own screen with a phone — that's the analog hole, and Claude Design's native share doesn't even attempt it. A dynamic watermark makes the capture self-incriminating rather than impossible — it's deterrence and attribution, not prevention. On the desktop, screenshot protection deters the easy in-app capture; on mobile, Screenshield blocks screen capture and recording on supported devices. None of these are magic. But together they raise the cost of leaking an unreleased design and strip the leaker of anonymity, which a public publish link does nothing to provide. For the deeper mechanics, we wrote a full dynamic watermarking guide. On Peony, dynamic per-viewer watermarks live on the Data Room plan at $52/admin/month, and desktop screenshot protection starts on Business at $30/admin/month.

How do you protect an unreleased product UI — and handle versions as the design changes?

Treat the unreleased UI as a deliverable with a lifecycle, not a one-shot link. This is the in-house-design-lead case, and it has two parts the public link can't touch: protecting the design and versioning it.

For protection, stack three controls. Gate the export behind an NDA so the client or partner acknowledges confidentiality before the design renders. Stamp a per-viewer watermark so any leaked screen is traceable to one person. And if part of the design isn't ready to show — an unannounced feature, a pricing screen, a co-brand you can't reveal yet — redact it before sharing rather than maintaining a separate "safe" cut you'll inevitably send to the wrong person.

For versioning, this is where a design differs from most files: designs iterate, and a stale link is a real risk. When you publish v1 to a public URL and then ship v3, the v1 link still works forever — so a stakeholder can be reacting to a flow you killed two weeks ago. Sharing through a controlled, version-tracked link fixes that: the client always sees the current cut, and when a direction is dead you revoke the old link so nobody reviews the wrong thing. A public publish link has no concept of "this version is retired." A deliverable does.

How do you actually share a Claude Design with a client in Peony?

Here's the concrete workflow, end to end — the part where the thesis becomes clicks. The job is to take the design Claude built and put it in front of a named client under control, at a flat $52/admin/month on the Data Room tier (no Enterprise required):

1. Export from Claude Design. For an interactive prototype, export standalone HTML; for a static one-pager or deck, export PDF/PPTX/image. (Peony shares both — the difference is whether the client clicks through a live prototype or reads a fixed page.)
2. Upload it to a Peony room. The exported .html renders live with its JavaScript executing, so the client gets the working prototype, not a flattened screenshot. A PDF/image one-pager renders as the controlled document it is.
3. Turn on a per-viewer dynamic watermark. Each viewer sees their own name, email, and a timestamp across the design — so a leaked unreleased screen is attributable.
4. Add an NDA gate if it's confidential. A Simple NDA is acknowledge-to-enter; an Advanced NDA captures a signed PDF before the design renders.
5. Redact anything not ready to show, instead of sending a separate cut.
6. Send one tracked link per stakeholder. Page-level analytics tell you who opened the prototype, when, and which screens they spent time on.
7. Set the link to expire or revoke when review ends or the design changes — and rely on version control so the client always sees the current cut.

There's also a faster path if you live in Claude. Peony exposes a publicly available MCP server that's bidirectional — an AI agent can read a room's contents and push an artifact into the room. In practice that means you can finish a design, install the Peony MCP, and push the exported prototype straight into a watermarked, revocable room without leaving the chat (the "publish from Claude" flow). And if you ever need to go further, the Enterprise tier lets you connect your own GPT, Claude, and Gemini under zero-retention, permission-scoped, audited access — though a designer sharing one prototype with one client is nowhere near needing that.

The honest concession — when the public Claude share link is the right call. If the design is public work you'd be glad to see reshared — a portfolio piece, a conference mockup, a marketing one-pager, a community concept — use Anthropic's native public share link. It keeps the prototype interactive, costs nothing extra, and a data room would be pure overkill. The same goes if you just need a quick internal look from a teammate already in your Anthropic org: the org-internal comment link is the right tool. Peony is for the other job — the confidential client deliverable. Knowing which job you're doing is the entire skill, and I'd rather point you at the free link than sell you a room you don't need. The companion piece, best tools to share a Claude artifact securely, lays out the public-link options (ShareDuo, Stacktree, LiveSend) honestly for exactly that case.

The bottom line: share the design like what it is

Decide one thing first — is this design public or confidential? — and the right workflow falls out:

• Public / portfolio work (a marketing mockup, a conference concept, a community-facing one-pager): use the native Claude Design public link. It's interactive, free, and a data room would be overkill. A public link is a portfolio, and that's exactly what you want here.
• A teammate inside your Anthropic org: use the org-internal comment/edit link. No export, no host, no Peony.
• A confidential client deliverable (an unreleased product UI, a brand system, a pitch one-pager, an investor prototype): export the design and share it like a deliverable — rendered live, per-viewer watermarked, NDA-gated, tracked, redactable, and revocable — at a flat $52/admin/month, not Enterprise.

Claude Design makes the work in minutes; the share decides who controls it. Peony is the data room used by 5,900+ customers precisely because it lets you keep the prototype alive and stay the gatekeeper, instead of trading one for the other. And when the share genuinely doesn't need control, I'll happily point you at the free public link — because a portfolio and a deliverable are two different jobs, and the whole point is doing the right one.

Sources

• Introducing Claude Design by Anthropic Labs — Anthropic (April 2026): product launch, Claude Opus 4.7, prototypes/slides/one-pagers, export and handoff.
• Anthropic launches Claude Design, a new product for creating quick visuals — TechCrunch (April 17, 2026): launch coverage and positioning.
• Get started with Claude Design — Claude Help Center: research preview availability, export options, share/handoff mechanics.
• Manage project visibility and sharing — Claude Help Center: org-scoped view/comment/edit links and public share-link behavior.
• Peony product documentation — live HTML rendering, dynamic per-viewer watermarks, NDA gating, page-level analytics, redaction, link expiry/revoke, MCP server, and flat $52/admin/month pricing. peony.ink

---

Disclaimer: This article is for general informational purposes and is not legal advice. Confirm NDA, confidentiality, and data-handling requirements for your specific engagement with qualified counsel. Product capabilities and Claude Design behavior reflect what was publicly documented as of July 2026 and may change.