Guide · July 21, 2026 · 8 min read
How to Share a Claude Artifact Privately (Password, Your Own Domain, No Login for Viewers)
You built something in Claude — a proposal, a one-page report, a little interactive demo — and now you need to send it to a client who has never heard of Claude and never will. You hit Publish, got a link, and then the doubt kicked in. Is this thing public? Will it show up in Google? Can I put a password on it? Can I even tell if they opened it?
Here's the honest summary before the details: a published Claude artifact is public until you unpublish it, it has no password or viewer-level access control, and Claude gives you no setting to keep it out of search. For plenty of uses that's completely fine. For a client hand-off it often isn't. This walks through how to share a Claude artifact the way you actually need to — from "just publish it, it's fine" all the way to pulling the HTML out and hosting it privately on your own domain — and it's straight with you about which path fits which situation.
Does your client need a Claude account to open it?
No — for a public link. This is the thing people worry about for no reason: someone with no Claude account can open a published artifact. Anthropic's own help article on publishing artifacts says so plainly — non-users view a published artifact without signing up. They only get pushed toward an account if they try to use AI features baked into it.
So a static thing — a deck, a proposal, a report, a landing page — opens fine for anyone with the link. Two situations bite people, and both produce the same "why is it asking my client to log in?" moment:
- Team and Enterprise artifacts can only be shared inside the org. If you created the artifact in a Team or Enterprise account, the share mode keeps it inside your organization, and viewers have to sign in as members of that org to see it. That's useless for an outside client. For a hand-off to someone outside your company, export the page (next section) and host it somewhere public — you can't turn an org-only artifact into a public link.
- Interactive, model-calling artifacts require the viewer to sign in. If your artifact calls Claude live at runtime, or a Claude Code artifact is wired to MCP connectors, an account-less viewer sees empty or locked sections. For a hand-off, keep it static — plain HTML, no live model calls.
Rule of thumb: static content, public link, no problem. Anything "smart" that talks to the model, expect a login wall.
Getting the HTML out of the chat
Three real paths. Which one you want depends on whether you're keeping it inside Claude or taking it somewhere with more control.
Path A — Publish in place. In the artifact panel, hit Publish/Share and you get a public claude.ai link. Thirty seconds, zero setup. Right move when the content is genuinely public or low-stakes.
Path B — Copy the HTML out. The clean way to take the source anywhere else. Ask Claude in plain words: "Create a downloadable, self-contained index.html for this artifact, with all required CSS and JavaScript included." Download the resulting file and open it locally in your browser before you upload it anywhere. And if you're in Claude Code and it created an .html file in your project, just use that file on disk — but don't confuse it with Claude Code Artifacts, which are organization-only shared pages on Team and Enterprise, not necessarily a local file.
Path C — Screenshot or print to PDF. A frozen snapshot. Rarely what you want for anything interactive, but worth knowing it's there.
One gotcha catches almost everyone the first time. After you export, test the page outside Claude before you send it. If your artifact pulls in an external CDN script, a Google Font, or a remote image, it can render perfectly in the chat and then look broken once it's on its own — remote assets fail for all sorts of reasons: a Content Security Policy that blocks them, hotlink protection, expired URLs, or missing authentication. For the most portable hand-off, bundle your assets locally and avoid dependencies you don't control. The fix is usually one sentence back to Claude: "Inline all CSS and JS, and embed every image as a data URI."
Is a published artifact public? Will Google index it?
This is the section that matters most, so I'll be blunt.
Yes, publishing makes it public. Anthropic's own wording is "anyone with the link can view and interact with it." It's link-based — you're not dumped into a public directory — but native publish has no private tier and no password option. Anyone who has the link is in.
Claude does not expose a noindex setting. There's no switch to tell Claude to keep a published artifact out of search. Because Anthropic itself calls the link public, don't treat the obscurity of a hard-to-guess URL as a privacy control. Treat a published artifact as effectively public, and don't put anything in one you'd be uncomfortable seeing surfaced.
One more thing worth knowing: revocation is all-or-nothing. You can Unpublish to kill the link entirely, but you can't selectively revoke one person or restrict who sees it. It's on for everyone, or off for everyone — and native publish gives you no way to verify who's on the other end of the link.
Can you password-protect it or set it to expire?
With native Claude publish: no, no, and no.
- No password.
- No expiry. Links don't expire and can't be set to.
- No view tracking. You can't see if, when, or how often it was opened.
- No "only these people."
Team and Enterprise admins can set an org-wide retention policy (auto-delete after N days) and there's a Compliance API to list and delete artifacts, but that's admin housekeeping, not a per-link expiry a normal user controls.
So if your checklist includes any of {password, expiry, view tracking, per-person access, keep it out of search, put it on my own domain}, native publish can't do it. That's not a knock on Claude — it's just not what the publish button is for. Which leads to the real decision.
Share it as-is, or host it yourself?
Three tiers. Pick the lowest one that meets your needs. Don't over-engineer a throwaway.
Tier 1 — Just use native Publish. Genuinely right when the content is public or low-stakes: a portfolio piece, a public demo, a link for people who all have Claude accounts in your org. Free, instant, no infrastructure. If that's you, stop here — adding a tool would be silly.
Tier 2 — Extract the HTML and host it on a static host. For a no-terminal upload, Netlify Drop — drag a folder onto the page — is the fastest route. For a repository-backed site with a custom domain, use Cloudflare Pages, Vercel, Netlify, or GitHub Pages. Best when you're comfortable technically and want a permanent, self-owned home.
The honest caveats: these are all public unless you configure access controls yourself. You'll get search visibility unless you add a noindex meta tag or a robots rule. Password protection is a paid feature on most of them (Netlify's site-wide password lives on paid tiers) or something you wire up by hand. You get full control, but the hosting is now yours to run and configure.
Tier 3 — A private-by-default page host. This is for the reader who ticked most of the boxes above: no account for the viewer, keep it out of Google, an optional password, your own domain, and did they actually open it. If you need an unlisted, noindex page with an optional password and view tracking, Pagelive fits — you bring the extracted HTML and it becomes a link that's unlisted and noindex by default, staying out of search unless you deliberately flip it public. You can add an edge-enforced password and, on a paid plan, put it on your own domain, and the view tracking answers the "did the client open it, and when" question that native publish simply can't. It also has a remote MCP connector, so from Claude Code you can tell Claude to publish the page and get the live URL back in one call.
Be clear-eyed about what Pagelive does not do, because it changes when it's the wrong pick. It doesn't verify the viewer's identity: anyone with the link (and the password, if you set one) can open it. There are no per-person permissions and no automatic expiry. So if you need to restrict a page to one named client, or have the link self-destruct after a deadline, reach for a host or access-control product that explicitly supports that — not Pagelive. And if you just want a quick public link, Tier 1 is simpler and free. If you need a real web app — server-side code, multiple routes, forms that persist, logins for viewers — you need an application platform, not any single-page publisher. Pagelive publishes the self-contained HTML you bring; it's not a website builder, a file-transfer service, or a place to run a backend, and you shouldn't reach for it expecting those.
The failure modes people actually hit
- "It's blank / it's asking my client to log in." Usually one of three: you sent the chat URL instead of the published link; it's a Team/Enterprise org-only artifact that needs org sign-in; or it's a model-calling/connector artifact that requires viewer auth. Fix: for outside clients, export the page and host it publicly, and keep it static.
- "It broke after I published or moved it." A remote CDN script, font, or image failed to load. Inline everything and test the exported file before sending.
- "The form doesn't save anything." An artifact is one self-contained page — no backend, no server-side state. Real forms or persistence means real hosting, not a publish button.
- "I only want to un-share it from one person." Not possible in native publish. Only global Unpublish.
- "I assumed a private-looking link meant hidden." It doesn't. No noindex setting. Assume public.
The takeaway
It comes down to two questions. Does the viewer need a Claude account? No — for a public link, anyone with it can view a static artifact. Does anything about this need to stay private? If no, native Publish is free and done. If yes — a password, out of search, your own domain, proof they opened it — native publish can't do it, so you extract the HTML and host it somewhere that can: a static host you configure yourself, or a private-by-default page host that starts unlisted and noindex and tracks opens for you. Just know what "private" means for each: an unlisted, password-gated link keeps a page out of search and casual view, but it doesn't check who opens it — if you truly need per-person access or a hard expiry date, that's a job for an access-control product, not a page publisher. Match the tool to the stakes and you'll never over- or under-share again.
Frequently asked
Does someone need a Claude account to open a shared artifact? +
No — for a static artifact, anyone with the public link can open it without signing up. The exceptions are org-only shares on Team and Enterprise, and interactive artifacts that call the model at runtime, which do require the viewer to sign in.
Is a published Claude artifact private? +
No. Publishing makes it public to anyone with the link — there is no password, no per-viewer access, and no noindex setting. You can Unpublish to kill the link entirely, but while it is live, treat it as public.
Can you password-protect a Claude artifact? +
Not in native publish — there is no password, expiry, or view tracking. To get those, export the HTML and host it somewhere that supports them: a static host you configure yourself, or a private-by-default page host.
How do I get the HTML out of a Claude artifact? +
Ask Claude to output the complete, self-contained HTML in one code block (or download it), then open the file locally to check it before uploading. If it renders broken, ask Claude to inline all CSS and JS and embed images as data URIs.
How can I tell if a client actually opened the link? +
Native publish can't tell you. A private page host with view tracking, like Pagelive, shows whether and when the page was opened and how long the viewer stayed — a signal a public claude.ai link doesn't give you.
Related: publish the website Claude built you · how Pagelive keeps pages private
Sharing a Claude artifact with a client?
Paste the HTML, get a private branded link with an optional password — unlisted and off Google by default, and you'll see when they open it. Free for 5 pages, no card.