What plans include artifacts?

Artifacts are available on Pro, Max, Team, and Enterprise plans, and the session has to be signed in with your Claude account. They aren't available when you authenticate with an API key or a cloud-provider credential, or through Amazon Bedrock, Google Cloud's Agent Platform, or Microsoft Foundry.

Who can see an artifact I create?

Only you, until you share it. From the page's Share control you can grant access to specific people or everyone in your organisation on Team and Enterprise plans, or create a public link anyone can open. On Team and Enterprise, public sharing is off until an owner enables it for the organisation.

Can an artifact show live data rather than a snapshot?

Yes. A page can call MCP connectors each time someone views it, so it renders current data instead of what the session gathered when it was built. Each viewer's calls go through their own connected account, so two people opening the same dashboard may see different data depending on their access.

Is an artifact a real application?

No, and that's deliberate. It's a single self-contained page with no backend — it can't store form input, serve multiple routes, or authenticate viewers itself. For an internal tool that needs a backend, build and deploy it properly; artifacts are for capturing and sharing work.

Claude Artifacts: turning a session into a shareable page

There’s a specific kind of frustration that comes at the end of a good piece of analysis. Claude has done the work — found the pattern, compared the options, traced the problem — and now you have to communicate it. So you copy blocks of text into Slack, where they lose their formatting and their meaning, and someone replies “can you just walk me through it?”

Artifacts are the answer to that last mile. Instead of text you have to relay, Claude publishes a page you can send.

What an artifact actually is

An artifact is a live, interactive web page that Claude publishes from your session to a private URL on claude.ai. You open it in a browser. It updates in place as the session continues working — so a page created at the start of a long task fills in while the task runs.

Claude writes the page as an HTML or Markdown file in your project, then publishes it. Before publishing something new it asks permission — you’ll see a prompt naming the page it wants to publish. Approve it, and Claude prints the URL and opens your browser.

Ask for one in plain language:

Make an artifact that compares these four vendor proposals side by side, with the cost breakdown as a chart and a one-line trade-off under each.

You don’t need to know what HTML is. You need to know that some results are easier to look at than to read.

When a page beats a paragraph

The rule of thumb: reach for an artifact when the output has structure that text flattens.

A dashboard from work already done. Claude has pulled the numbers during the session — deploy failures by service, campaign performance by channel, spend by team. A chart says it in a glance.

Options laid side by side. Four possible layouts, three implementation plans, five candidate suppliers. Comparison is inherently spatial; a list of paragraphs is the wrong shape for it.

An annotated walkthrough. Rather than describing what changed and why, a page can show the change with your reasoning in the margin next to the relevant part.

A timeline that fills in while you wait. For long-running work, an artifact that updates as it goes means anyone with the link can follow along without asking for updates.

Interactive controls. Sliders and toggles bound to whatever you’re tuning, so you can try values rather than describe them.

Something to send instead of pasting. Honestly, this is the most common one. A link is a better artefact of your work than a wall of copied output.

A new artifact is visible only to you. Sharing is an explicit act, done from the Share control in the page header.

What’s available depends on your plan:

Within your organisation — on Team and Enterprise, you can grant access to specific people or to everyone in the organisation. Viewers sign in to claude.ai to see it.
Publicly — a link anyone can open with no sign-in. On Pro and Max, this is the only sharing option. On Team and Enterprise, public sharing is off by default until an owner enables it for the organisation — which is the right default for a company.

Every publish creates a version, and you choose which version viewers see. That’s more useful than it sounds: you can keep iterating on a page without your audience watching the mess.

On Team and Enterprise you can also make someone an editor rather than a viewer. An editor updates the page from their own Claude session by giving Claude the artifact’s URL — Claude pulls the current content and republishes with their changes. Everyone with the page open sees it update live.

The genuinely clever part: live data

This is the feature that turns artifacts from “a nice output format” into something operationally useful.

An artifact can call MCP connectors each time someone opens it, so the page shows current data rather than a snapshot from whenever it was built. Ask for it directly:

Build a dashboard artifact of our open pull requests that pulls the live list through my GitHub connector when the page loads.

The security design here is worth understanding, because it’s better than the obvious approach:

Each viewer uses their own connectors. Calls go through the viewing account’s connections, not the author’s. Two people opening the same dashboard may see different data depending on what their accounts can access.
The page never sees credentials. claude.ai makes the calls on the page’s behalf.
Viewers approve first. Each viewer is asked before the page’s first connector call. Decline, and you see the page without its live sections.
The page can only call what was declared. Claude declares which connectors the page may use at publish time, and it can’t reach outside that list.

That model means a shared dashboard doesn’t leak the author’s access to everyone who opens it — which is exactly the failure mode you’d worry about.

One consequence to plan around: a connector-backed artifact can’t be shared to a public link on any plan. On Team and Enterprise you keep it private or share within the organisation; on Pro and Max, where public is the only sharing route, it stays private to you.

And a practical tip from the docs worth repeating: ask Claude to include a fallback message in each live section naming the connector it needs. A viewer missing that connection then sees what to connect, rather than an empty box.

What it isn’t

An artifact is a capture of work, not an application, and the constraints follow from that:

No backend. It can’t store what someone types into a form or authenticate viewers itself.
Single page. No separate routes; long content uses in-page anchors.
No external requests. A strict content policy blocks scripts, fonts, and images from other hosts — everything is inlined. Connector calls are the one exception, and those are handed to claude.ai rather than made by the page.
Size limit. The rendered page must be 16 MiB or smaller; oversized embedded images are the usual culprit when a publish fails.

If what you actually want is an internal tool with a database and logins, build it properly and deploy it. Artifacts are for showing work, not hosting product.

Worth knowing about cost, too: generating an artifact uses output tokens like any response, and a styled page costs more than the same content as plain text. Images embedded as data URIs are the biggest contributor. If you’re producing them frequently, prefer diagrams drawn as SVG or CSS over embedded images, and skip interactivity you don’t need.

For teams and IT

If you’re deploying this across an organisation, the controls exist and are worth setting deliberately:

Artifacts can be enabled or disabled organisation-wide, and on Enterprise scoped to specific roles.
Connector calls from artifacts have their own separate toggle — you can allow artifacts without allowing them to pull live data.
Public sharing is off by default on Team and Enterprise and must be turned on by an owner.
Retention policies can be set separately for private and shared artifacts.
Publishing, sharing, and deleting each appear in the audit log, and a Compliance API can list, retrieve, and delete artifacts programmatically.
If your network restricts outbound access, allowlist the sandboxed *.claudeusercontent.com origin the viewer loads from, alongside claude.ai.

Individuals can also turn artifacts off for their own sessions regardless of the org setting.

The habit worth forming

Next time you finish a piece of work and find yourself about to paste a large block of output to a colleague — stop and ask for an artifact instead.

It’s a small change with a disproportionate effect on whether your work actually lands. The analysis was always good. What changes is that the person receiving it can see it, in one page, at the URL you sent — instead of reconstructing it from a wall of text in a chat window they’ll scroll past.