Stacktree

List the share links on one of the user's pages: each link's id, label, expiry, use limit and whether it was revoked, with how many times it has been opened and when it was last opened. Open counts are null on plans that do not include viewer numbers.

list_share_links

List sites owned by the authenticated user, newest-updated first. On plans without viewer numbers each site carries metrics_locked: true, view_count/unique_viewers/last_viewed_at are null, and opened still reports whether anyone has opened it. Each site carries its client space (or null); filter with the client argument. Pages that expired or were deleted stay in this list rather than disappearing: check deleted_at before handing anyone a url, because a row with deleted_at set is a dead link, and restore_site puts it back until restorable_until passes. Paged: the response carries has_more, and when it is true, next_before and next_before_id. To read the rest, call again passing those two values as before and before_id, and repeat until has_more is false.

list_sites

Mark a feedback item as addressed after fixing the page. Pass the feedback item id from list_feedback, and a short note describing what you changed: the reviewer who left the comment sees it on the page.

resolve_feedback

Create a separate link to one of the user's pages for a single recipient, labelled with who it is for. Opens through the link are counted under that label, and the link can be revoked on its own without affecting the page or its other links. The link opens the page without its passcode, so create one only for someone the user wants to have access.

create_share_link

Used by the Stacktree publish card in the chat: a short-lived owner preview link for one page, which opens it without counting as a visit and without asking for its passcode. Read-only. Not a link to send anyone: it stops working after 15 minutes.

publish_card_open

The Stacktree viewer for an .html file the user opens in ChatGPT desktop: preview it, publish it to a private link, add a passcode, send it to a named client, and keep the page in sync as the file changes. ChatGPT calls this itself when the user opens the file. A file path does not work here: to publish a file you can read, call publish_html with its contents.

open_html_file

The pages, and the named people, that have not opened what was sent to them an hour after it went up, newest first. Most pages are opened within the hour they are sent, so one that is still quiet has usually not gone out: hand the person their link again (each item carries it), or ask your user who an unnamed page is for and call whos_it_for. Read-only.

unopened_pages

Turn HTML into a link a person can open in a browser. It only ever creates a new page: it never changes or deletes one that already exists (update_site replaces a page in place). Reach for this whenever a page you produced has to be seen by someone who is not in this conversation — a client, a teammate, a reviewer, a channel — or when the user says "publish this", "share this", "send it to X", or asks for a preview link to something you built. A rendered preview inside a tool is not a link: if it has to travel, publish it. Returns { url, id, expires_at, ... }; hand the url back. Privacy-first defaults: unguessable token URL, plan-aware expiry (permanent on paid plans, 7 days on free — its ceiling), a safety scan that blocks accidental publication of personal data or secrets (nothing is collected or stored by the scan), strict CSP, X-Robots-Tag: noai. Pass expires_in_hours: "never" for permanent links — on the free plan a permanent page is REFUSED, not silently shortened: you get 409 expiry_clamped naming the date it would have got, and either you pass accept_clamp: true to take the 7 days or you tell the user the plan cannot make a link permanent. Never report a page as permanent without expires_at being null. Read expires_at_iso and ttl_seconds off the response and tell the user when the link dies. The free plan allows 3 pages in total; the count is lifetime, so deleting a page does not free the slot. RETRYING: pass idempotency_key (any unique string, a UUID is ideal) and a retry of the same call returns the SAME page instead of publishing a second one. Reuse the key when you retry after a timeout or an unclear failure; use a new key for new content.

publish_html

Publishes the new version of a page that has feedback and resolves the comments it answers, in one step. The HTML is replaced in place, exactly as update_site does (same link, so everyone holding it sees the new version; the old one is kept in list_versions). Then each listed comment is resolved with its note, and one message back to the reviewer is left with them. The reviewer sees the notes and the message next to their comments the next time they open the page. Use it instead of update_site when the new version answers feedback from get_revision_brief. If the update is refused, nothing is resolved.

publish_revision

Restore a page that was deleted or expired in the last 30 days. It comes back at the same URL, with the same id, slug and history, so links already shared work again. Use it when update_site or a settings tool answers 409 site_deleted; publishing the page again would give it a new URL instead. A page past its 30 days, or one removed for breaking the terms of use, cannot be restored and answers 404. The response gives the new deadline in expires_at and expires_at_iso; tell the user that date. restored_for says which deadline it got: "grace" means the page had expired and is back for 48 hours, "kept" means it kept the deadline it had, and "plan" means it has the usual lifetime for the account. A 402 plan_site_limit_exceeded means the account has reached its number of live pages. If a retry answers 404, call get_site to check whether the first attempt already restored the page.

restore_site

Read a page’s content back. format "html" (the default) returns the exact stored index.html, byte for byte, which is the only form you can edit and hand to update_site; format "text" returns the same page stripped to plain text — no markup, CSS, scripts or SVG — which is what you want when you only need to read, summarise or quote a page and the markup would be most of the tokens. Only pages this account owns, gated ones included. A page that expired or was deleted still reads back until its restore window closes, so this doubles as "get me a copy before it is purged"; a page taken down for abuse does not. Never edit the text form and publish it: that would throw the page’s design away.

get_content

Read the current HTML source of a site you own, so you can edit it and call update_site to change it in place. Returns the exact stored index.html (not a rendered or text-stripped version), preserving CSS and inline charts. Use this to personalize a template or iterate on a published page without re-fetching the live URL. To READ a page rather than edit it, get_content with format: "text" returns the same page stripped of markup, which is a fraction of the tokens.

get_site

Who this connection is publishing as, and what its plan actually allows. Returns the account’s plan, the signed-in email, how many pages it holds and how many lifetime publishes it has spent, and a limits object. READ limits RATHER THAN QUOTING NUMBERS FROM ANY OTHER TOOL DESCRIPTION: those describe the free plan, the account you are connected to may be on any plan, and limits is what the server will actually enforce. Worth calling before promising a permanent link (max_expiry_hours), before promising a passcode or an email gate (passwords, email_gates), and when a publish comes back 402 or 429, so you can tell the user which wall they hit and how much of it they have used. The email is also the answer to "where did my page go": pages live in one account, and the commonest cause of a missing page is a second one, so say WHICH account is connected rather than that the page does not exist. auth_method reports how this connection authenticated ("apiKey" or "oauth"). It reads nothing about anyone else and touches no page.

get_me

Read viewer comments left on a site, unresolved first. Each item from the page comment layer has `target` (one line saying what it is about, in the page source's own terms), `target_kind` (text | image | video | audio | embed | graphic | element | page) and `anchor`: for text the exact quoted words plus prefix/suffix; for images the src attribute as written in the HTML, alt text and the point clicked (0-1 across/down); for video/audio the src and the timestamp in seconds; `anchor.selector` is a CSS path to the element. Find the target in get_site's HTML by quote or src, not by selector alone. Older Agentation items carry element, selected_text, intent and severity instead. Open comments also carry `on_page`: true while their target is still in the page, false once an edit has removed or reworded it (usually answered, so resolve it), null when that cannot be told from the source. The loop: list_feedback → edit with get_site/update_site → resolve_feedback with a note saying what changed (the reviewer sees that note).

list_feedback

Used by the Stacktree publish card in the chat to refresh itself: the page’s link, whether and by whom it has been opened, its passcode, expiry and client. Read-only. An agent answering the user should use list_sites or list_share_links instead.

publish_card_status

Rename a client space, archive or unarchive it, or set the viewer gate that covers every page in the space. Omit a field to leave it untouched. A rename changes the display name only — the slug is a permanent addressing contract and never moves. Archiving frees the space’s plan slot and closes its portal and connected address to readers (they see a "no longer available" page); every page keeps working at its own link. Unarchiving reopens them, takes a slot back and returns HTTP 402 when the plan is full. password and allowed_email_domain gate the whole space and are inherited by pages already filed under it as well as ones published later; pass null to remove either. Passcodes work on every plan (free covers 3 across pages and spaces); email gates start on Solo, so setting allowed_email_domain on a free plan returns HTTP 402 plan_viewer_gate_not_available. Clearing a gate, or changing one the space already carries, always works. A 409 name_taken means another active space already answers to that name — report that rather than retrying with a variation, which would leave the user with two spaces for one client.

update_client_space

Resolves several comments on one page in one call, each with a short note, plus one optional message back to the reviewer. For when nothing needs publishing: approvals, or comments an earlier update already answered. The person who left each comment sees the note next to it on the page, so write it to them. Ids that are not open on this page are skipped and reported back.

resolve_comments

Restrict viewer access to an email domain, to named people, or both. Paid plans only: on a free plan this returns HTTP 402 plan_viewer_gate_not_available. Anyone visiting the URL must verify, via a one-time magic link, that they own a listed address or one at a listed domain. Pass domain: null to clear. Mutually exclusive with set_password — clear one before setting the other.

set_email_gate

Kill one share link. The page and every other link keep working — this is how you cut off one recipient without re-issuing anything to the others.

revoke_share_link

Put an earlier version of a page back at the same URL, after a bad update. Get the version id from list_versions first. Same link, same id, same read history, so nothing needs re-sending. This is NOT restore_site: restore_site brings back a page that was DELETED or expired, this rolls a live page’s content back to what it said before. The content that is live right now is snapshotted first, as a new version, so this is itself undoable and new_version in the response is the id that undoes it. Report that. SINGLE FILE ONLY: on a page with other files this puts index.html back and leaves the rest as they are, and the response carries partial: true saying so. A 404 version_not_found means that id is not a version of this page (it may have aged past the plan’s retention cap); a 409 site_deleted means the page itself has stopped serving, so call restore_site first and then this. Nothing is changed in either case.

restore_version

Record who a published page is for, by name, and get back that person’s own link to hand over. Ask your user who the page is for before you hand a link over, then call this once per person. Every open through the link comes back with their name, and if they have not opened it an hour after it went up, the owner’s dashboard says so. It records only: nothing is sent to anyone. Unlike create_share_link, the link keeps the page’s passcode or email gate in front of it. To file the page under the person’s company, use set_client.

whos_it_for

Set or clear (null) the passcode viewers type to open a page. Works on every plan (free covers its 3 pages). The passcode belongs to the page: invent a new one, and never ask for or reuse anyone's real password or personal credentials.

set_password

Set hours-from-now expiry, or null for never. A number longer than the plan allows is shortened to the ceiling and the response says so (expiry_clamped: true). Asking for NEVER on a plan that caps page lifetime is refused instead: 409 expiry_clamped, nothing changed, and the body carries the date it would have set. Pass accept_clamp: true to accept the ceiling, or tell the user the plan cannot make this page permanent. The response carries expires_at, expires_at_iso and ttl_seconds: quote that date rather than the one you asked for.

set_expiry

Show the passcode set on a page this account owns, so it can be sent to the client again. Works for passcodes set since 13 September 2026 (kept as an encrypted copy beside the hash the gate checks). An older one answers not_retrievable: the page still asks for it, and the fix is set_password with a new one, then send that.

get_passcode

Take a page down. The link goes dead immediately for everyone holding it, and the content is kept for 30 days: restore_site puts it back at the same URL, with the same id, token, slug and read history, any time in that window. After the 30 days the content is destroyed and cannot be recovered by anyone. So this is undoable, but it is not a preview: tell the user their link stops working now. On the free plan deleting does not hand back a lifetime page slot, because that cap counts publishes rather than live pages. Deleting a page that is already down is not an error: the response comes back with already_deleted: true and the same restorable_until.

delete_site

Replace the HTML of an existing site in place. The URL stays the same, so everyone you already sent it to sees the new version without being sent anything. Use this — not another publish_html — every time you revise a page you have already published: iterating with publish_html strands the link people are holding on the old version and burns a page slot. The pre-publish safety scan runs on the new content too (MCP default: block), preventing accidental publication of personal data or secrets. A 409 managed_portal means this page is a generated client portal: it rebuilds itself from its space, so direct edits would be overwritten — the owner can "customize" it from the space settings in the dashboard, which stops regeneration for good. A 409 site_deleted means the page has stopped serving and is being kept for 30 days: call restore_site on the same id first, then update it. Do not publish it again: that mints a second page at a different URL. When the page has open client comments the response carries `comments`: how many are open, which ones no longer match the new version (ids_no_longer_on_page, most likely answered by this change) and what to do next: resolve those with resolve_feedback and a short note.

update_site

Where an approval request stands. state is "approved" only when every approver has approved the version that is live now (the whole page, or every section); "changes_requested" when anyone has asked for a change; otherwise "pending". Per approver: status, their note, when, and section by section progress. An answer about an earlier version does not count: if you update the page, approvals of the parts that changed lapse.

get_approval_status

Lists the pages you have published on Stacktree, newest first, with their links, viewers and expiry.

stacktree_pages