Website content

Returns the workspace's sites, each with page, folder and per-status counts, newest first. sitemap_last_edited is the later of the site's own sitemap_updated and the last change to any of its pages; sort=-sitemap_last_edited puts the site most recently worked on first. A "site" is a sitemap: the page tree plus the instructions that content is generated from.

Creates an empty site. Pages are added afterwards — by hand, by importing an existing sitemap, or by having a structure proposed from a description of the business.

Returns the site and every page under it in one response. Pages carry node_parent and node_order, so the tree is rebuilt from a flat list rather than requested level by level. The pages come without node_content: a body is the largest thing a page carries and a site has no bounded number of pages, so a tree that carried every body would grow past what one response can hold. Read the body of one page from GET /sites/{id}/pages/{page_id}, or pass include=content to fetch the site with every body inline — for an export, where the whole thing is the point.

Soft delete. The site and its pages stop being listed; nothing is removed from a connected CMS.

Applies the sitemap_-prefixed fields present in the body. This is the site itself; its pages are edited through the page endpoints.

Chooses how the site's pages are reviewed: default follows the workspace's default approval flow, flow names one in flow_id, and none turns review off for this site. Requires content:workflow:edit rather than content:edit, because deciding what review a site gets is the same decision as defining the flows. Pages already approved or published land on the new flow's final step; pages mid-review re-enter at its start. The answer names the flow now governing the site in governing_flow — with default that is whichever flow holds the role, and with none it is null.

Marks every generated page on the site as approved in one step, for a site reviewed in bulk rather than page by page.

Every comment thread on the site, one row each, newest activity first — the review status of a whole site without fetching a page at a time. Threads only: replies are counted in cmt_reply_count and their authors listed in cmt_participants, and the full conversation is read from the page it is on. Each row names its page in cmt_page and its anchor in cmt_anchor_label, resolved against the page as it stands; cmt_anchor_unattached marks a thread whose field has since been moved or removed. Filter with status=open (the default) or status=resolved.

Sets the agent used when generating this site's content. Requires content:generate rather than content:edit — choosing who writes is part of generating, not part of editing the site.

A single page overrides this by naming an agent in its own node_instructions_params.contentAgentId.

Queues content generation for each empty page that has instructions of its own or inherited from a parent. Returns once the work is queued; generation runs in the background and pages move to draft as they complete.

A page that names its own agent in node_instructions_params.contentAgentId is written by that one, so a single run can span pages written by different agents. agentId covers the rest.

Starts background brief generation, one job per page. Returns as soon as the jobs are queued, not when they finish — poll the site's briefsJob for progress.

Drafts the site-level instructions every page inherits, reading the live site where one exists.

Proposes a page tree from a description of the business, for a site that does not exist yet. Returns the proposal for review — it is not saved until you import it.

The site's instructions for the two passes that follow the copywriter, beside the platform defaults they replace when set: review (what the review agent writes about each page) and editor (what the editor agent is told to enforce and report). Set through the site's sitemap_config: reviewInstructions and editorInstructions, beside the agents themselves in reviewAgentId and editorAgentId. A page appends its own notes in node_instructions_params.reviewInstructions / editorInstructions.

Builds the page tree from URLs or page titles. Accepts a urls array, sitemap XML, a url to fetch the XML from, or a plain one-per-line list — the parser is deliberately tolerant, because this input is usually pasted by a person. A list with nothing URL-shaped in it is read as page titles: each line becomes a page whose slug is made from the title, and a line indented under the one before it becomes that page's child.

Every listed path becomes a page, whether or not other listed paths sit beneath it: a section landing page is still a page. A segment that appears only as an ancestor becomes a folder, since nothing was said about it. A type of page or folder, from a column or the sidecar, decides either way, and on a path that already exists it changes the node in place, except that a page holding content is never turned into a folder.

A comma, tab or semicolon separated file is read as a table when its first row names the columns: url (or path, slug) locates the page, name (or title) names it, and instructions and type are applied the same way the instructions sidecar is. A heading is matched on any word it carries, so V1 URL (slug) is a URL column; a table with a name column and no URL column gets its slugs from the names. Without a recognized header row the first URL-looking cell of each line is taken and the rest of the line is discarded. A page that arrives without a name is named after its slug, dashes to spaces and words capitalized. On a dry run the response reports which format was read and which columns went unused.

It also accepts a site export: post the exported document as the body, or its nodes array on its own. A URL path cannot carry capitalization, sibling order, or two pages under the same folder sharing a slug, so an export is the input that survives a round trip — the tree, page names, order and type are read from the file. Pages are matched on the ids in the file, then on their slug path, and updated where they match; nothing is deleted, so a page the file no longer mentions stays. Content in the file is written as a draft, which withdraws any sign-off it had, exactly as editing the page would.

Adds a page or folder to the tree. Omit node_order and it is appended to the bottom of its sibling group, which is almost always what you want — passing 0 collides with every existing sibling.

node_slug is the page's own URL segment and is derived from node_name when omitted. Two pages under one parent cannot share it, so a slug already in use is numbered off it (about, about-2) and the response carries the one the page was given.

One page: what it is for, what has been written into it, and how far through review it is.

Removes the page and everything filed under it.

Applies the node_-prefixed fields present in the body. Writing content directly is allowed — generation is one way to fill a page, not the only one. Writing node_content into a page that had been approved withdraws that sign-off: the page returns to draft and re-enters the site's review at the first step, since nobody has read the text it now holds. The approved copy is kept — POST /sites/{id}/pages/{page_id}/restore-approved puts it back.

A node_slug that another page under the same parent already answers to is refused with 409: the address was named rather than derived, so numbering it off would publish the page somewhere other than where it was asked for.

node_type moves a node between page and folder; pages under it stay either way. A page that holds content is refused as a folder with 409. Discard the content first.

Looks at one image and writes alt text for it in the context of this page: the site, the page, the field it sits in (fieldPath) and the copy beside it. The image is either a file of the workspace (file_id, which the caller must be able to read) or a public web address (url, fetched once and never stored). Returns the text for review; nothing is saved until the page is. currentContent lets an editor pass unsaved copy and instruction steers this one run.

The content as it stood when the page was last signed off, which is not what node_content holds once anyone has edited it. Editing an approved page returns it to draft and keeps this, so it answers both "what changed since approval" and "what does the live website still show". 404 while nothing about the page has ever been approved — node_approved_at on the page says which it is.

Hands the page to a member of the workspace, or takes it from them with assignee_id: null. Assignment says who the page waits on and nothing more — it does not move the page, and workflow moves do not change it. The new assignee is notified.

Requires either content:edit or content:review.

Returns every comment on the page in one response, threads and replies together, oldest first — group them by cmt_parent rather than requesting a thread at a time. A thread names what it is about through cmt_field_path, an array of field keys and array indices addressing one part of the record (["body", 0, "headline"]); a thread with no field path is about the page as a whole. Filter with status=open or status=resolved; resolution belongs to the thread, so replies are filtered with the thread they are in.

Starts a thread, or replies to one when cmt_parent is given. A reply inherits the anchor and the resolved state of the thread it joins, so it takes no cmt_field_path of its own. A path is stored as sent except that array indices are normalized to numbers, so ["body", "0"] and ["body", 0] are one anchor rather than two. Anyone named in cmt_mentions is notified, as is everyone already in the thread.

Soft delete, by the author or by anyone holding content:comment:delete. Deleting the first comment of a thread removes its replies with it.

Rewrites the text of your own comment. Moderating someone else's means deleting it, not rewriting what they said.

Puts a resolved thread back on the open list.

Marks the thread settled and drops it out of the open list. Nothing is deleted — a resolved thread is the record of the review, and reopening restores it.

Queues this page to be written from its brief and the site's knowledge, into the shape its content schema declares. Returns once the work is queued, not when the copy is ready: the page sits in generating and moves to draft when it lands.

The writer is the agent this page names in node_instructions_params.contentAgentId, falling back to agentId and then to the site's agent.

Rewrites one field of a page's structured content, optionally against an instruction, leaving the rest untouched. The page must already have structured content to regenerate a field from.

The same as generating the whole site, scoped to one branch — every empty page beneath this node, however deeply nested. The node may be a folder or a page that has pages under it.

Writes an SEO meta title (at most 60 characters) and meta description (at most 150) from the page's draft copy. The content template's metaTitleInstructions and metaDescriptionInstructions replace the platform defaults (see GET /content-schemas/meta-defaults); the page-level notes are appended. Returns the pair for review; nothing is saved until the page is. The page must hold draft content to write from. currentContent lets an editor pass unsaved copy; instructions overrides the saved page-level meta instructions for this one run.

Frees a page stuck in generating, back to draft where it still holds copy and empty where it never had any, so it can be edited again. The queued job is not recalled: copy that lands later is still saved. Answers 409 when the page is not generating.

Requires either content:edit or content:generate.

What has happened to a page, newest first: every workflow move, who made it, and the note they left, and every write into its copy with what made it in history_ref.source. Page content itself is omitted — this answers how a page got where it is, not what it said at each point, which GET /sites/{id}/pages/{page_id}/versions does.

Runs the site's editor agent over the page's saved copy, in the background, without regenerating it. The editor reads the brief the page was written to and its own guideline knowledge, corrects wording that breaks them, and lists each change in editor.changes with the rule it serves. The structure is never touched: fields, blocks, images and links come back exactly as saved, only words change. Answers 202 with the page marked node_metadata.proofreading; the copy is not touched, so the page keeps its status and stays editable. The record lands under node_review.editor when the editor is done, or the failure under node_metadata.lastProofreadError, and either clears the mark; the corrected copy waits on the record as proposed and reaches node_content only when a caller applies it, marking each change applied. A page already being proofread is answered as it stands; one that is generating is refused with 409. The editor is the agent this page names in node_instructions_params.editorAgentId, then agentId, then the site's; a page that opted out of the automatic pass is still proofread here, since the request is the opt-in. 400 when no editor is set. instructions stands in for the page's editor notes for this one run.

Takes one document as a multipart upload (files field) and stores it as reference material for the page. Put the returned file_id into an entry of the page's node_instructions_params.referenceUrls ({fileId, name, note?}) and generation reads the document the way it reads a reference link. PDF, Word, PowerPoint, Excel, CSV, plain text and Markdown are accepted.