← Plugin catalog
Developer Tools

Unbounce - Classic Builder

Unbounce Marketing Solutions Inc. v1.0.405

Create Unbounce Landing Pages

Create a free account to save this plugin.

From the developer

Not specified in the available declarations: capabilities, limitations, pricing & account requirements.

Onboarding example

Use my brand guidelines to build a landing page for our summer sale with an email signup.
Sources & dates

Developer declarations; not independently tested. Listing last checked Nov 22, 2026. Package observed Nov 21, 2026.

View package source →

Description

From the marketplace listing

Connect your Unbounce account to create and edit landing pages, add A/B test variants, set traffic splits, and check page performance without leaving the chat. Describe the page you want and Unbounce will build it; ask for a new variant, a headline change, or a conversion report and it's handled in your account. Works with your existing Unbounce pages, domains, and page groups. Requires an Unbounce account and the Classic Builder.

Language: English · Automatically detected from descriptions.

What changed

· 4 observations

Capabilities & instructions

Full description changed from “an Unbounce landing page through Unbounce MCP — writing the HTML/CSS/JS for create_page_from_html, create_variant_from_html, and update_variant_from_html....” to “a Classic Unbounce landing page from HTML/CSS/JS through Unbounce MCP — create_page_from_html, create_variant_from_html,...

View comparison →
Capabilities & instructions

Full description changed from “page variant as clean responsive HTML through Unbounce MCP. Use when the user asks to modernize a page, make a page responsive, get rid of absolute...” to “Classic page variant as clean responsive HTML through Unbounce MCP. Use when the user asks to modernize a page, make a page...

View comparison →
Capabilities & instructions

App-6a7a3df1e608819188444011032d91cc updated; open the comparison for details. Unbounce updated; open the comparison for details. Brand color added: “#0033FF”. Logo url dark removed: “https://files.openai.com/content?id=file_00000000d39c81f79c9773fa732f88f4”. 7 more changes in the comparison.

View comparison →

Technical updates · 1

Package or technical metadata updated

View technical comparison →

· 2 observations

Capabilities & instructions

App-6a7a3df1e608819188444011032d91cc updated; open the comparison for details. Unbounce updated; open the comparison for details. Brand color added: “#0033FF”. Logo url dark removed: “https://files.openai.com/content?id=file_00000000d39c81f79c9773fa732f88f4”. 6 more changes in the comparison.

View comparison →

Technical updates · 1

Package or technical metadata updated

View technical comparison →

Similar plugins

Finding similar plugins… Results will appear here automatically.

Browse plugins →

Files & skills

File archives

Plugin package75 files · 352 KBBrowse files →
Skill instructions
mcp-ai-builder-authoring28.5 KB

View saved version →

---
name: mcp-ai-builder-authoring
description: How to build or edit an Unbounce AI Builder page through Unbounce MCP — get_ai_builder_catalog, create_ai_builder_page, get_ai_builder_document, edit_ai_builder_page, then publish_page — and what makes the page good. Use by default when the user asks to create, build, design, or generate a new Unbounce landing page (AI Builder is the default route for a new page unless the account's plan lacks it or they ask for a Classic or custom-HTML page), and whenever the page to edit, restyle, or publish is an AI Builder page, including a colleague's. Carries a menu of design-system references to style a page from.
requires:
  mcpServers:
    - unbounce-mcp
---

# Authoring an Unbounce AI Builder page

An AI Builder page is stored as an **editor document**: a JSON component tree
(GrapesJS project data) built from the components in the client's AI Builder
catalog and styled with the client's style guide. You author that document;
Unbounce validates it, stores it, and renders it.

## Which route

Each account in `list_accounts_and_clients` carries `builders`: whether its
plan includes AI Builder (`ai_builder`) and the Classic Builder (`classic`),
each true, false, or null when it could not be read. Read it before choosing.

- **AI Builder is the default** for a new page unless `ai_builder` is false.
- Use the Classic HTML route (`create_page_from_html`, the `mcp-page-authoring`
  skill) when `ai_builder` is false, when the user asks for a Classic or
  custom-HTML page, or when the catalog genuinely cannot express what was asked
  for — for example a bespoke interactive widget or custom page-level
  JavaScript. Not when `classic` is false: that plan has no Classic Builder.
- With both false the plan includes neither of these builders (it may still
  have another, such as Smart Builder), and no page can be created here. Tell
  the user.
- Tell the user which route you took and why.
- An existing page stays on the route it was built with. A Classic page is
  edited with the Classic tools; an AI Builder page with the tools below.

## These pages are editable in the Unbounce AI builder

A page made or changed here is an ordinary AI Builder page. The user — and
anyone else on the client — can open it and keep editing it in the Unbounce AI
builder (`create_ai_builder_page` returns its `editor_url`). The "cannot be edited
in the Unbounce builder" rule is about **Classic pages authored from HTML only**
and does not apply here; never tell the user an AI Builder page is MCP-only.

## What does not work on an AI Builder page

These tools refuse an AI Builder page, so say so instead of trying them:

- The Classic HTML tools: `update_variant_from_html`, `create_variant_from_html`,
  `bulk_edit_variants`, `get_variant`.
- `create_variant_from_existing_variant` — there is no MCP way to add a variant
  to an AI Builder page.
- `set_conversion_goals` and `get_layout_hints`.

`set_variant_standing` works, with one limit on these pages: promoting the
current champion or a discarded variant is rejected
(`set-variant-standing.upstream-validation`) — bring a discarded variant back
as a challenger first. `set_page_metadata` works (see "Page metadata" below).
`set_traffic`, `set_variant_name`, `manage_page_redirect`, `get_page_stats`,
`reset_page_stats`, `unpublish_page`, and `delete_page` work as on a Classic
page. A page with no traffic recorded yet
returns `variants: []` with a `variants_unavailable` note, on any builder.

## Finding a page

`list_accounts_and_clients` returns each client with `clientUuid` and `clientId`.
Pass `clientUuid` as `client_uuid` to `list_client_pages`; `clientId` is the
numeric `context` the AI Builder tools take.

`list_client_pages` lists **Classic pages only by default**. To find an AI Builder
page — "edit my colleague's page" — pass `builder: "ai_builder"` (or `"any"` for
both). Under those scopes `total` is absent and `next_after` is a heuristic: keep
paging until `next_after` is g

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 59 — file references are metadata, not package contents.

mcp-feedback4.55 KB

View saved version →

---
name: mcp-feedback
description: Record a user's feedback about the Unbounce MCP tools — a bug, praise, a feature request, confusion, or anything else — straight to the team via the submit_feedback tool, with no copy/paste. Use when the user wants to report a bug, share feedback, praise something, request a feature, or flag that a tool was confusing. Also covers login/connection issues — the user can't connect the MCP in their client, sees an OAuth error ("access denied", "invalid_grant", a failed redirect), or keeps getting asked to log in again. You may also offer it after a hard MCP tool failure. It confirms the exact content with the user and redacts secrets before anything is stored.
requires:
  mcpServers:
    - unbounce-mcp
---

# Submit Unbounce MCP feedback

Record the user's feedback about the **Unbounce MCP tools** to the team's store by
calling the **`submit_feedback`** tool. The tool persists the record server-side, so
nothing has to be copied out of the conversation into Slack or anywhere else.

> The `mcp-` prefix here means "pertains to Unbounce MCP," not "about a page." This
> skill is about capturing feedback on the MCP tools themselves — whether they broke,
> delighted, confused, or fell short.

## Hard rule: report, don't repair

**Do NOT try to fix, retry, or work around the thing being reported.** This skill
records feedback on what already happened. Never invent tool-call arguments or error
text — anything not actually present is `unknown`. (Fixing the underlying task, if the
user wants that, is separate work done after the feedback is recorded.)

## 1. Gather the feedback

Settle two things — from the conversation where possible, asking only what you can't
infer:

- **`type`** — one of `bug` · `praise` · `feature_request` · `confusion` · `other`.
- **`message`** — the feedback in the user's own words. Keep it faithful; don't
  editorialize.

For a **`bug`**, also assemble the **`context`**: the verbatim failing tool call(s)
from the transcript — exact tool name, exact arguments JSON, and the raw result/error
text (call out any `code`/`reason`/`remedy` fields). Include the relevant one(s),
especially the failing call. If the failure happened in another session and isn't in
the transcript, ask a couple of targeted questions and mark transcript-only fields
(exact arguments, exact raw error) as `unknown`. For non-bug types, `context` is
usually unnecessary — include a light pointer (the tool or page in question) only if
it genuinely helps.

**Login / connection problems** are a `bug`: capture what the user was doing, the
client they're in, and the exact error text (e.g. `access denied`, `invalid_grant`, a
failed redirect, repeated re-login prompts). Note that if the MCP can't connect _at
all_, `submit_feedback` itself won't be reachable — that's expected, and step 4's
inline fallback is how the feedback still gets out.

## 2. Redact secrets

Replace any access token, API key, password, or bearer token in the `message` or
`context` with `«REDACTED»`. Count how many you redacted. (The server re-scrubs as a
backstop, but do your pass first — the user is about to review this content.)

## 3. Confirm the exact content, then submit

Show the user the **exact record** you're about to store — the `type`, the `message`,
and the `context` if any (post-redaction) — and get an **explicit yes** before
calling the tool. This is the consent step; do not skip it and do not submit
silently. (Same ask-first bar the page tools hold for Dynamic Text Replacement.)

On yes, call **`submit_feedback`** with `type`, `message`, and `context` (if any). The
server stamps identity, timestamp, and build itself — you don't pass those.

## 4. On failure, don't lose the feedback

If `submit_feedback` fails (an error result, the tool isn't available, or an older
deploy predates it): **retry once.** If it still fails, **print the composed,
already-redacted record inline** in the conversation and tell the user to pass it to
the team direct

Preview of the first 4,000 characters. Read full instructions →

mcp-modernize12.5 KB

View saved version →

---
name: mcp-modernize
description: Rewrite an imported (absolutely-positioned) Unbounce Classic page variant as clean responsive HTML through Unbounce MCP. Use when the user asks to modernize a page, make a page responsive, get rid of absolute positioning, make a clean-HTML version of an existing Classic page, or edit a page that was hand-built in the Unbounce Classic builder — phrasings like "modernize this page", "make my page responsive", "convert my old page", "clean HTML version". Replication-faithful — this is a layout rewrite, never a redesign. Not for AI Builder pages, which stay editable as they are (mcp-ai-builder-authoring).
requires:
  mcpServers:
    - unbounce-mcp
---

# Modernizing an Unbounce page (responsive rewrite)

Turn a page built in the Unbounce builder into clean, responsive flexbox/grid
HTML — **pixel-faithful to the original on desktop, reflowing sensibly on
mobile**. This is a REPLICATION task with zero creative latitude: same copy,
same images, same fonts, same colors, same element counts. The only thing that
changes is the layout model (absolute positioning → flex/grid).

The pipeline is two deliberate stages:

1. **Import** — `create_variant_from_existing_variant` clones the builder-built
   source into an MCP-managed variant that renders identically (deterministic;
   every string, image URL, font, and form field lands in the copy verbatim).
2. **Rewrite** (this skill) — read that copy, restructure its layout to
   responsive flex/grid, and write it back **in place** with
   `update_variant_from_html`.

Extraction fidelity is stage 1's job and it is deterministic — never work from
the original builder page directly, and never re-derive content from screenshots
or memory. Your job is only the layout transformation.

## Language with the user

Never say "modernize", "modernization", "replica", or platform-internal terms
to the user. Their page is fine; say "make your page responsive" and "an
editable copy of your page". The result cannot be edited in the Unbounce
builder — all future edits go through MCP tools; say so at handover, and never
suggest the builder.

## Workflow

**Step 1 — Resolve the target.** Identify the page (`list_client_pages`) and
variant (`list_page_variants`). If the target variant is builder-built (not
MCP-managed), tell the user in one line what is about to happen — e.g. _"I'll
create an editable copy of your page, then make that copy responsive — your
original stays untouched"_ — then run `create_variant_from_existing_variant`
(no `target_page` ⇒ new page). No further permission ceremony is needed; the
copy is additive and safe. Relay any conversion warnings honestly. A
fixed-width "autoscale" source converts fine — the conversion report notes that
runtime viewport scaling isn't preserved; that is expected and harmless here,
because you rewrite the page responsive from scratch (Step 4), discarding the
scaling entirely. If the target is already an MCP-managed imported copy, skip
straight to Step 2.

**Step 2 — Read the copy.** `get_variant` on the imported variant. Download the
`html_ref` / `css_refs` sources and any `scripts` entry's `ref` (via `download`, or
`download_inband` if you cannot run shell commands). This body is the **sole
source of truth** for every value: copy strings, image URLs (with their
`srcset`), `@font-face` blocks, colors, dimensions, form fields, `<ub:dynamic>`
tags. Never guess a value, never take one from a screenshot, never reconstruct
from memory. If the copy came from an autoscale source, its CSS wraps lengths in
`calc(<px> * var(--scale, 1))` and it may carry a viewport scale script —
ignore both: read the plain px value (the `* var(--scale)` is the fixed-width
scaling you are removing) and never copy the scale script into the rewrite. Your
responsive layout comes from the Step 3 rows, not these fixed dimensions.

**Step 3 — Get the layout skeleton and fidelity signals.** `get_layout_hints`
on the same variant. It returns, per section: `rows` 

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 5 — file references are metadata, not package contents.

mcp-page-authoring27.2 KB

View saved version →

---
name: mcp-page-authoring
description: Best practices for authoring a Classic Unbounce landing page from HTML/CSS/JS through Unbounce MCP — create_page_from_html, create_variant_from_html, and update_variant_from_html. Use when the user asks for a Classic or custom-HTML page, when a new page needs something the AI Builder catalog cannot express (a bespoke interactive widget, custom page-level JavaScript), when the account does not have AI Builder, or to edit or add a variant to a page already authored through these HTML tools; also to personalize page text by URL parameter (Dynamic Text Replacement). A new page otherwise goes through the mcp-ai-builder-authoring skill. Not for AI Builder pages or pages hand-built in the Unbounce builder.
requires:
  mcpServers:
    - unbounce-mcp
---

# Authoring an Unbounce MCP page

These rules apply when you write the HTML/CSS/JS body for `create_page_from_html`,
`create_variant_from_html`, or `update_variant_from_html`. The page is a full-bleed
custom-HTML page — you own the markup end to end. Design the page to be optimized
for conversions: by default, every layout, copy, and hierarchy decision should
serve the page's single conversion goal.

This covers **MCP-authored pages only**, and the split is exclusive both ways:

- A page hand-built in the Unbounce builder is not editable this way —
  `update_variant_from_html` refuses it. Replicating or modernizing a
  builder-built page is a different, audit-first job.
- An MCP-authored page **cannot be edited in the Unbounce builder**. Never tell
  the user they can open, tweak, swap images, or finish the page "in the
  Unbounce builder/editor" — they cannot. Every edit goes through these MCP
  tools: the user asks for the change, or supplies updated HTML.

AI Builder pages (`create_ai_builder_page`, `edit_ai_builder_page`) are a separate
route covered by the `mcp-ai-builder-authoring` skill; they stay editable in the
Unbounce AI builder, so the rule above does not apply to them.

A new Classic page needs the Classic Builder on the account's plan: check
`builders.classic` for the client's account in `list_accounts_and_clients`. When
it is false, take the AI Builder route instead and tell the user why;
`create_page_from_html` refuses such an account before anything is uploaded,
with `create-page-from-html.classic-builder-not-entitled`, or
`create-page-from-html.no-builder-entitled` when the plan has neither builder. A
`create-page-from-html.not-author-or-not-entitled` at the create means the user
is not an author on the client or the plan lacks the Classic Builder; `builders`
tells them apart.

## Updating a variant: HTML/CSS replace, JS is left alone

`update_variant_from_html` full-replaces the body HTML and the stylesheet, so
send every stylesheet the variant should keep on every call. **JavaScript is the
exception: omit `scripts` and the variant's existing custom-JavaScript elements
are kept**, reported back as `scripts_preserved`.

That matters because a variant can carry scripts nobody authored through these
tools — an **Unbounce popup** attaches itself as one. So:

- Editing HTML or CSS? Just omit `scripts`. The popup and anything like it
  survive, and you don't need to know they were there.
- Changing the scripts? Pass `scripts` with the **complete** desired set — it
  replaces all of them, including external includes. Whatever it drops comes
  back in `removed_scripts`. Those entries — and the `scripts_preserved` ones —
  are already in `scripts` entry form: pass one straight back to restore it,
  unchanged, no translation. A plain include appears as `src` (with `async` /
  `defer` if it had them); everything else — including an include whose tag
  carries other attributes, such as a `data-*`-configured analytics embed — comes
  back as verbatim `tag`. Read the variant first
  (`get_variant`) if you don't know what's there.
- Removing every script is deliberate: pass `scripts: []`.

## Writing a `scripts` entry

Each entry is one cu

Preview of the first 4,000 characters. Read full instructions →

Referenced files: 2 — file references are metadata, not package contents.

Package details

Publisher declarations from the archived package. These are separate from our research and the live service's terms.

Package author
Unbounce Marketing Solutions Inc.

Package observed Nov 21, 2026.

Technical details
First seen
Sep 30, 2026 · 22:02 UTC
Last seen
Nov 22, 2026 · 12:00 UTC
Latest observed change
Oct 28, 2026 · 12:26 UTC
Collection status
Collected

plugin_asdk_app_6a7a3df1e608819188444011032d91cc

Download plugin data (JSON)

Plugin details: freshly prepared. Prepared . Refreshed when plugin data changes or after 6 hours. Your account and Follow status are live.