Unbounce - Classic Builder

Read objects from your server-side workspace, returning their content INLINE in this tool's result. Use this ONLY if you cannot run shell/`curl` commands locally; if you can, prefer `download`, which streams the bytes to disk without passing them through this conversation. Pass the `upload://<handle>/<relpath>` references returned by `upload`, `upload_inband`, or `get_variant`. Only small text objects can be returned this way — a binary object (image/font) or one over 2 MiB is refused, with guidance to use `download` instead. Any refused reference fails the whole call, so retry with just the good ones.

download_inband

Return a page's A/B stats — page-level totals plus a per-variant breakdown of `visits`, `visitors`, `conversions`, and `conversion_rate` — by `page_uuid` (from list_client_pages). Also includes each variant's `conversion_rate_delta` and statistical `confidence`. Numbers are all-time cumulative since the last reset by default (see reset_page_stats); pass `start_date`/`end_date` (RFC 3339 UTC timestamps) to narrow to a period. `visits` sum exactly across adjacent windows, but `visitors`/`conversions` are visitor-deduplicated and attributed to the period where first counted, so a narrow window can show fewer than the events inside it; no window reaches data zeroed by a reset. `conversions` counts conversion-goal hits deduplicated per visitor — NOT the number of form submissions (the two totals legitimately differ). Every variant comes back in one response (no paging), and `last_reset_at` is the last reset's timestamp, or null if never reset. Errors if the page isn't found or accessible.

get_page_stats

Fetch an MCP-managed variant's current draft content — body HTML, CSS, and JavaScript — into your workspace so you can inspect or edit it and re-submit with update_variant_from_html. Identify the variant by page_uuid (from list_client_pages) and letter (a/b/c, from list_page_variants). Returns the editable source as html_ref / css_refs upload:// references plus a `scripts` array (one entry per custom-JavaScript element: a `ref` to an editable .js file, an external `src` include, or verbatim `tag` markup) — pass them straight back to update_variant_from_html; the bytes never pass through this conversation. This is DRAFT (editor) content, which may differ from what's published if the variant has unpublished changes. Also returns the variant's conversion_goals (the configured goal set plus candidates) and its metadata (SEO title/description/keywords, robots noindex, favicon, Open Graph — settable via set_page_metadata). The source refs are streams and do NOT render individually in a browser — for a local preview, use the also-returned preview_ref: a standalone preview.html composed for viewing (fetch it with download or download_inband). preview.html is view-only; never submit it back as html_ref. Source is returned for MCP-managed variants only — for a variant hand-built in the Unbounce builder the result degrades to is_mcp_managed:false with its conversion_goals and metadata (both readable for any variant), an autoscale flag (true when the Classic page scales a fixed-width design to the viewport rather than reflowing per breakpoint), and no source refs.

get_variant

Return an Unbounce account's plan (name, billing interval) and subscription (renewal date, price with currency). Defaults to the authenticated user's primary account; pass `accountUuid` (from list_accounts_and_clients) to target a specific accessible account. `plan` and `subscription` come back null when your role can't see billing details — visible only to an Account Owner or Administrator, null for Authors and Viewers. That's a normal result, not an error.

get_account_plan

Return a client's asset library — uploaded images and files — by the client's numeric `context` (from list_page_variants' `page.context`, or a clientId). Each asset carries its numeric `id`, `uuid`, `name`, `content_type`, `file_size`, and a servable `cdn_url`. Drop a `cdn_url` straight into the HTML/CSS passed to create_page_from_html / create_variant_from_html / update_variant_from_html to reuse that asset without uploading a duplicate (external URLs pass through untouched). Returns metadata and URLs only, never the file bytes. Listing appears to require an author role on the client — a client you can list pages for may still be denied here (HTTP 403). Paginated by `after`, but not the standard first/total contract: this backend returns a bare array with a fixed page size and no total count. Omit `after` for the first page; if the response includes `next_after`, pass it back as `after` for the next page, and keep going until `next_after` is absent.

list_assets

List the custom domains a client owns, by `client_uuid` (from list_accounts_and_clients). Returns `{ domains: [{ name, state, is_default, certificate_status }], total }`. `name` is the domain string a page can be published on (see set_page_url); `state` is `ok`, `moving`, or `move_error`; `is_default` marks the account's default domain; `certificate_status` is SSL readiness (`ok` means the domain serves HTTPS). The list is complete (unpaginated); an empty list means the client has no domains, not an error.

list_client_domains

List the page groups (named folders for organizing pages) a client uses, by `client_uuid` (from list_accounts_and_clients). Returns `{ groups: [{ group_uuid, group_id, name, page_count }], total }`. Use `group_uuid` with manage_page_group and delete_page_group. The list is complete (unpaginated); an empty list means the client has no custom groups. The UI's "All Pages" view is not a real group and is never listed.

list_page_groups

Return a client's landing pages, by `client_uuid` (from list_accounts_and_clients), with optional server-side filters and sort. Each page carries its `pageUuid` (feed to list_page_variants), numeric `pageId`, `name`, `url`, `state`, an unpublished-changes flag, last-published timestamp, `routing_strategy` (`smart_traffic` / `weighted` / `single` — the authoritative traffic mode; omitted if unset), and `routing_config` naming the variant letters in play for that mode (the allocation letters for smart_traffic; `champion` + `weights` for weighted; the serving `variant` for single). For a page's variants and their traffic split, call list_page_variants with the `pageUuid` — a per-page variant count isn't returned here because the platform's own count is unreliable for pages under an A/B test. Paginated: `total` is the full post-filter count, and `next_after` (when present) is the offset to pass as `after` for the next page; page until it's absent. An empty list means no matching pages, not an error.

list_client_pages

Return a page's variants (by `page_uuid` from list_client_pages), ordered champion, then other active variants, then discarded. Each variant carries its numeric `variant_id` (the id the page-editing tools take), its `letter` (a/b/c label), name, its stored SEO `title` and `description` (metadata is per-variant and unsynced, so divergence shows here at a glance — set with set_page_metadata, full set via get_variant), its `standing` (champion/challenger/discarded — the same vocabulary set_variant_standing takes, so you can round-trip without translating), the raw platform `state` (testing/paused/untested/discarded), traffic `weight`, `is_champion`, `has_conversion_goal` (whether the platform counts anything as a conversion on it — get_variant returns the goal definitions themselves), and a `preview_url`. The `page` block includes `context` (the owning client's numeric id the page-editing tools require) and `routing_strategy` (`smart_traffic` / `weighted` / `single`), the authoritative traffic mode: under `smart_traffic` the platform allocates dynamically, so a variant's `weight` is the stored split, NOT the live allocation — do not infer an A/B test from weights alone. `routing_config` names the variants in play for that mode (the letters in the Smart Traffic allocation; the `champion` + per-variant `weights` for a weighted test; the serving `variant` for single). `routing_strategy` and `routing_config` are both omitted when the page has no routing strategy set. `preview_url` opens that variant's staged rendering in the Unbounce app for a human to review (not edit) — it requires the viewer's own Unbounce session, so it is NOT a public URL and cannot be fetched or screenshotted by the agent. `include_discarded` defaults to true; set false to return only the live set (`discarded_count` is reported either way). Errors if the page isn't found/accessible, or isn't a landing page.

list_page_variants

Return the Unbounce accounts the authenticated user can access, each with its clients. Calls the Unbounce API on the caller's behalf.

list_accounts_and_clients

Attach, replace, or remove a page redirect (by `page_uuid` from list_client_pages) that forwards visitors from the page's own URL to another URL — the page stops serving its content, so this is how you retire or forward a published page without deleting it. `action: "set"` creates the redirect, or replaces an existing one; it needs `redirect_url` (an absolute URL) and an optional `status_code` (301 permanent, the default — for retiring/replacing a page for good, so search engines transfer the old URL's ranking to the target; 302 temporary — the original URL keeps its equity). `action: "remove"` restores the page's own content. Both apply IMMEDIATELY — no publish step — and are reversible (`remove` undoes `set`). This does NOT preserve a page's old URL after set_page_url: a redirect attaches to a page at its current URL and points away, so it can't resurrect an already-orphaned URL. Returns `{ ok: true, action, ... }`.

manage_page_redirect

Publish a landing page (by `page_uuid` from list_client_pages), making its current draft state live. Publishing is the commit step: content and traffic/routing changes made by other tools stage as draft and only take effect once the page is (re)published. The publish is asynchronous — this tool polls briefly and reports `done:true` with `state:"published"` once the page settles, or `done:false` with the in-progress state and a note to re-check later. Errors if the page isn't found, isn't a landing page, or can't be published.

publish_page

List common tasks you can accomplish with Unbounce MCP, each with an example prompt to ask for it. Takes no input. Returns `{ recipes: [{ title, prompts }], total, presentation }` — use it to discover capabilities and how to phrase a request. Present the result to the user as a list or table of title + full prompt(s) verbatim — never summarize, paraphrase, or truncate the prompts (see the returned `presentation` directive).

recipes

Rename one of an Unbounce page's variants, by `page_uuid` from list_client_pages and the variant `letter` a/b/c from list_page_variants. A variant's name is editor metadata, not page content, so the rename applies immediately — no publish_page step is needed and visitors are unaffected. Returns `{ ok: true, … }` with the new name on success, or `{ ok: false, code, reason, remedy }` so you can correct the inputs and retry.

set_variant_name

Zero ALL of an Unbounce page's A/B stats — every variant at once — by `page_uuid` (from list_client_pages). This is page-wide and IRREVERSIBLE, and it takes effect LIVE and IMMEDIATELY: there is no draft/publish step to undo it, and the visit/conversion history every variant decision rests on is gone the moment this returns. It starts a fresh measurement window. Call get_page_stats first if you want a fuller record. The response includes `wiped`, a best-effort snapshot of the totals just before the reset (as of the last stats aggregation, so it may omit the most recent traffic) — it is the only record you will have otherwise. Returns `{ ok: true, … }` on success, or `{ ok: false, code, reason, remedy }` so you can correct and retry.

reset_page_stats

Return which build of the unbounce-mcp server is running: the git commit SHA (full and short) the deployed artifact was released from, and the environment (integration, production, or local).

version

Set a page's SEO head fields and Open Graph (social-card) data: the `<title>`, meta description, robots noindex, favicon, and og:* tags. PARTIAL update: only the fields you pass change, `null` clears a field, omitted fields keep their value. Applies to ALL active variants by default — variants share one URL, so divergent metadata makes search snippets and social previews nondeterministic — pass `letter` to target one variant instead. `favicon` takes an `upload://` reference or an existing asset id/uuid (from list_assets); `open_graph.image` takes an absolute URL or an `upload://` reference (uploaded as a client asset; 1200×630 is the social-card convention). `title`/`description`/`keywords` accept Dynamic Text Replacement (`<ub:dynamic>`) tags — ask the user first. `keywords` is legacy (ignored by search engines since 2009) — usually leave it unset. Changes are STAGED in draft: a published page keeps its old metadata until publish_page. MCP-managed variants only; builder-built variants are skipped. The result echoes the applied metadata (also readable later via get_variant).

set_page_metadata

Set an Unbounce page's published URL — domain + path — by `page_uuid` from list_client_pages. `path` (required) is the new slug; `domain` (optional) defaults to the page's current domain, so you can change just the slug or move the page to another of the client's domains (from list_client_domains). The change applies immediately and puts the page into a `urlchange` state rather than staging as a normal draft edit, so you must (re)publish the page (publish_page) for it to serve at the new URL. Changing a published page's URL orphans the old one — existing links to it break. Returns `{ ok: true, url, domain, path, state, note }` on success; errors if the page isn't found or the URL is rejected (e.g. the path is already taken on that domain).

set_page_url

Declare which parts of an MCP-managed page count as conversion goals: the form submission and/or clicks on chosen links (http(s) or tel:). Takes the COMPLETE desired set and converges every active variant onto it — the form posts as a goal (/fsg) or non-goal (/fsn, still captures the lead), chosen links are rewritten to the platform's goal-click tracking, and the page's stored goal list is updated. Goal identity is the URL: every anchor sharing a chosen URL converts, and a URL must exactly match an anchor href somewhere on the page (candidates are listed by create_page_from_html / create_variant_from_html / update_variant_from_html / get_variant results) — an unmatched URL is rejected with the real candidates echoed back. Page-scoped: all active variants get the same goal set, keeping A/B conversion rates comparable; discarded variants are left alone. Changes are STAGED in draft — publish the page (publish_page) to make them live. Link/phone goals are tracked (a click on the published page counts as a conversion) but do NOT appear in the Unbounce builder's Conversion Goals panel for MCP-authored pages — that panel lists only builder-native elements. Manage these goals here, not in the builder.

set_conversion_goals

Stage how an Unbounce page splits visitors across its variants, by `page_uuid` from list_client_pages. Variant identifiers are letters (a/b/c) from list_page_variants. Choose a `strategy`: `single` (one variant serves all traffic — pass `champion`), `weighted` (fixed per-variant shares — pass `weights`, plus an optional `champion`), or `dta` (Smart Traffic dynamically allocates traffic — optionally pass `variants` to scope which take part). The change is STAGED in the page's draft and only goes live when the page is (re)published (publish_page). `weighted` (A/B testing) and `dta` (Smart Traffic) are paid features: if the account isn't entitled, the call is rejected up front before anything is staged — check the plan with get_account_plan, or use `single` to serve one variant. Returns `{ ok: true, … }` with the staged state on success, or `{ ok: false, code, reason, remedy }` so you can correct the inputs and retry.

set_traffic

Move one of an Unbounce page's variants through the A/B-test lifecycle, by `page_uuid` from list_client_pages and the variant `letter` a/b/c from list_page_variants. Choose a `standing`: `champion` (make this variant the page's baseline), `discarded` (pull a challenger out of the test — reversible, not a delete), or `challenger` (bring a discarded variant back into the test). This is the same `standing` list_page_variants reports for each variant, so you can read a variant's current standing there and pass the target one here without translating. The change is STAGED in the page's draft and only goes live when the page is (re)published (publish_page). Returns `{ ok: true, … }` with the staged state on success, or `{ ok: false, code, reason, remedy }` so you can correct the inputs and retry.

set_variant_standing

Record feedback about the Unbounce MCP tools — a bug, praise, a feature request, confusion, or other — to the team's feedback store, without copy/paste. Use the mcp-feedback skill to drive this: it composes the record, redacts secrets, and shows you the exact content for an explicit yes before calling this tool. The server re-scrubs secrets and stamps identity, time, and build itself; only `type` and `message` travel through the conversation. Returns the stored feedback id and how many secrets were redacted.

submit_feedback

Unpublish an Unbounce landing page, by `page_uuid` from list_client_pages, taking it offline so its URL stops serving. The unpublish is asynchronous: the tool polls briefly and reports `done:true` with `state:"unpublished"` once the page settles, or `done:false` with the in-progress state and a note to re-check. Errors if the page isn't found, isn't a landing page, or isn't currently published.

unpublish_page

Full-replace an existing MCP-managed variant's body (`page_uuid` from list_client_pages, variant `letter` a/b/c from list_page_variants) with already-uploaded HTML/CSS/JS: pass the `upload://` references from `upload` as `html_ref` (body-content HTML), optional `css_refs` (stylesheet), and optional `scripts` (custom-JavaScript elements). The HTML and CSS are a TRUE FULL REPLACE — CSS not passed on this call is REMOVED, so send every stylesheet you want the variant to keep, every time. JavaScript is different: OMIT `scripts` and the variant's existing custom-JavaScript elements are kept as they are (reported back as `scripts_preserved`) — that protects scripts added outside these tools, such as an Unbounce popup. Pass `scripts` to state the complete desired set and replace them; whatever it drops comes back in `removed_scripts`. Entries in `removed_scripts` and `scripts_preserved` are themselves `scripts` entries — pass one back unchanged to restore that script (a plain include appears as `src`, with its `async`/`defer`; anything else, including an include carrying other attributes, as verbatim `tag`). Pass `scripts: []` to remove them all. Referenced images and fonts are rehosted as client-owned Unbounce assets and the markup rewritten to the CDN URLs (reuse an existing asset via its `cdn_url` from list_assets instead of uploading a duplicate — uploads are deduplicated against the client's library); external http(s) URLs are left untouched. A `<form>` in the new HTML is automatically wired for lead capture; it must be well-formed — one `<form>` with named fields and a submit button, no `pageId`/`pageVariant` fields, no `onsubmit`/`onclick` handlers — or the call fails listing every issue. A wired form shows a default "Thank you!" confirmation dialog on submit, so it's never a silent dead end; register a `window.ub.hooks.afterFormSubmit` callback (in a `scripts` entry or an inline `<script>` in the body HTML) to customize the post-submit experience or suppress the default dialog. Only MCP-managed variants can be updated this way — a variant hand-built in the Unbounce builder is refused (import it into an editable MCP copy first with create_variant_from_existing_variant, or author a fresh variant with create_variant_from_html); the reverse also holds, an MCP-managed variant cannot be edited in the Unbounce builder. The change is STAGED and only goes live when the page is (re)published (publish_page), so editing a live champion is safe. Head metadata tags in the HTML — `<title>`, `<meta name="description|keywords|robots">`, `og:*`, `<link rel="icon">` — are lifted out and applied as this variant's metadata (reported under `head_metadata`, with a divergence warning when sibling variants exist — converge with set_page_metadata). Dynamic Text Replacement (`<ub:dynamic>`) is a paid feature: HTML containing it is rejected up front if the account isn't entitled (remove it, or check the plan with get_account_plan). File bytes are read server-side and never pass through this conversation.

update_variant_from_html

Upload local files (html/css/js + assets) to your server-side workspace without sending their bytes through this conversation. Returns one temporary upload URL per file; run the printed `curl -T <localfile> '<upload_url>'` for each (no auth header needed — auth is baked into the URL), so bytes go straight to storage, never through the model. Declare each file's exact byte size (`wc -c <file>`); the size is enforced on upload. Pass the returned `upload_path` values (`upload://<handle>/<relpath>`) to other tools — as html_ref for the HTML-authoring tools, or as an image/font reference inside authored HTML and bulk_edit_variants op values (rehosted to a client-owned CDN URL when applied). Each call creates a fresh upload folder, so refs are immutable snapshots — a later upload never changes what an existing ref points to. A relative reference written inside your HTML/CSS resolves only within the HTML's own folder: upload the HTML together with everything it references by relative path in ONE call, or write the full `upload://` ref in the markup instead. Can't run shell/curl? Use `upload_inband` instead.

upload

Upload text files (HTML/CSS/JS) to your server-side workspace by sending each file's content inline as a tool argument. Use this only if you cannot run shell/`curl` commands locally; if you can, prefer `upload`, which keeps bytes out of this conversation. Content rides through the conversation here, so keep files small and text-only — binary assets (images, fonts) are NOT supported: reference them by external http(s) URL instead, or reuse an existing asset's `cdn_url` from list_assets. Returns one `upload://<handle>/<relpath>` reference per file, usable anywhere the references from `upload` are — html_ref / css_refs, and a `scripts` entry's `ref`, for create_page_from_html / create_variant_from_html / update_variant_from_html. Relative paths share one upload folder, so a file can reference a sibling by relative path — but ONLY a sibling from the same call: each call (to this tool or to `upload`) creates a fresh folder, so refs are immutable snapshots and cross-call files must be referenced by their full `upload://` ref, not a relative path.

upload_inband

Return the authenticated Unbounce user (sub, id, email, first_name, last_name) by calling the Unbounce API on the caller's behalf.

whoami